rspec-junklet 2.1.3 → 2.2.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MDQxMTliMDE4Zjk5Yjg3NmQ4OTEwYzZhYTJkMmEzZjlmMzE4Mzg2ZQ==
-  data.tar.gz: !binary |-
-    ZTk1ZjllMmM4ZGJhNTI1YWU1OTA0NzNlY2FiNTk2ODQxYTNiOGY2Yw==
+SHA1:
+  metadata.gz: d86599950fe1c28302e71d4679251be2495ef794
+  data.tar.gz: d8696cb846ae80ed7db3658643f65160b566f6b8
 SHA512:
-  metadata.gz: !binary |-
-    NWU0ODIxODI2MmJkOTNkNDA4YWRkYjRhZjI4ZWE4ZWUwNGVmZDc0YjI3YmRj
-    OWQ5MmMxNDZkYmZlOGE1MTEwNDBlNmZiYzY3ZmMyNDQwOTIwM2JmZjIzM2Q4
-    NjFkZGNjNzA0NzJhY2Y0MTllYTYzMGNhM2M3MTQzYTlmZmExN2I=
-  data.tar.gz: !binary |-
-    Y2M0NWIzYmM1MDc0ZTUwOGQ4MjUyNGQxNDYwYmM4NzA1ODJiN2E4OWI2NjU1
-    M2EzMzg1OTZhNzAyYzNlMTRmMGZiZmVmZjA4NjBjZjZiODZiNzhlN2Q1ZDQw
-    ZDRmYzZhYTQwMmZlNTkzNTE4ODY0NmViYzY5ZmVhOWU1NThmYjc=
+  metadata.gz: 661c26d2f4d0317fd54bb28d4b581fd5a93d892036cf5b1633fdbd8bf42bbf5853c0ad97eb0550199ce8944edac88569d6b260eabdd4ffbf8d68caf869141e80
+  data.tar.gz: 85287ab4a12a9c6eb013f17b65a43a7dcf75550c92c56ce241efd6a71152b1626af96e810c10f2938fb4a4b57518de541395f1cffde754e43286a582707c19ec

data/.gitignore

@@ -32,3 +32,4 @@ build/
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+.byebug_history

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: .
   specs:
-    rspec-junklet (2.1.3)
+    rspec-junklet (2.2.0)
       rspec (>= 2.0, < 4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    byebug (9.0.6)
     coderay (1.1.0)
     diff-lcs (1.2.5)
     method_source (0.8.2)
@@ -15,14 +16,19 @@ GEM
       method_source (~> 0.8.1)
       slop (~> 3.4)
     rake (10.4.2)
-    rspec (2.99.0)
-      rspec-core (~> 2.99.0)
-      rspec-expectations (~> 2.99.0)
-      rspec-mocks (~> 2.99.0)
-    rspec-core (2.99.2)
-    rspec-expectations (2.99.2)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.99.2)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.2)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
     slop (3.6.0)
 
 PLATFORMS
@@ -30,6 +36,10 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.7)
+  byebug (~> 9.0)
   pry (~> 0.10)
   rake (~> 10.0)
   rspec-junklet!
+
+BUNDLED WITH
+   1.14.6

data/lib/rspec/junklet/formatter.rb

@@ -1,5 +1,10 @@
 module RSpec
   module Junklet
+    # Formatter.new(input) receives the generated junk, and #format returns the
+    # input already formatted. You don't have to inherit from this class; as
+    # long as your class accepts one argument to .new and responds to #format
+    # you're a formatter. Inheriting from Formatter means you already have a
+    # basic implementation, however.
     class Formatter
       attr_reader :input
 

data/lib/rspec/junklet/junk.rb

@@ -1,3 +1,5 @@
+require 'securerandom'
+
 require_relative 'formatter'
 
 module RSpec
@@ -67,14 +69,15 @@ module RSpec
           type = args.shift
           opts = args.last || {}
 
-          excluder = if opts[:exclude]
-                       if opts[:exclude].is_a?(Proc)
-                         opts[:exclude]
-                       else
-                         ->(x) { Array(opts[:exclude]).include?(x) }
-                       end
-                     else
+          excluder = case opts[:exclude]
+                     when Proc
+                       opts[:exclude]
+                     when Enumerator
+                       ->(x) { opts[:exclude].include?(x) }
+                     when nil
                        ->(x) { false }
+                     else
+                       ->(x) { Array(opts[:exclude]).include?(x) }
                      end
 
           formatter = case opts[:format]
@@ -83,11 +86,9 @@ module RSpec
                       when :int
                         ->(x) { x.to_i }
                       when Class
-                        raise "Formatter class must implement #format method" unless
-                          opts[:format].new(0).respond_to? :format
                         ->(x) { opts[:format].new(x).format }
                       when String
-                        ->(x) { sprintf(opts[:format], x) }
+                       ->(x) { sprintf(opts[:format], *Array(x)) }
                       when Proc
                         opts[:format]
                       else
@@ -133,10 +134,10 @@ module RSpec
           end
 
           val = if repeat.zero?
-                  value(generator, formatter, excluder)
+                  generate_junk(generator, formatter, excluder)
                 else
                   repeat.times.map {
-                    value(generator, formatter, excluder)
+                    generate_junk(generator, formatter, excluder)
                   }
                 end
           val
@@ -153,7 +154,7 @@ module RSpec
 
       private
 
-      def value(generator, formatter, excluder)
+      def generate_junk(generator, formatter, excluder)
         begin
           v = formatter.call(generator.call)
         end while excluder.call(v)

data/lib/rspec/junklet/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module Junklet
-    VERSION = "2.1.3"
+    VERSION = "2.2.1".freeze
   end
 end

data/rspec-junklet.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "byebug", "~> 9.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "pry", "~> 0.10"
   spec.add_dependency "rspec", [">= 2.0", "< 4.0"]

data/spec/lib/rspec/junklet/junk_spec.rb

@@ -1,196 +1,268 @@
 require 'spec_helper'
-require PROJECT_ROOT + 'lib/rspec/junklet/junk'
+require PROJECT_ROOT + 'lib/rspec/junklet/junk.rb'
 
-class JunkSpy
-  attr_reader :lets
-
-  include ::RSpec::Junklet::Junk
+RSpec.configure do |config|
+  config.extend(RSpec::Junklet::Junk)    # This lets us say junk() in describes and contexts
+  config.include(RSpec::Junklet::Junk)    # This lets us say junk() in describes and contexts
 end
 
-describe JunkSpy do
-  let(:junk) { subject.junk }
+describe ::RSpec::Junklet::Junk do
   let(:hex_regex) { /^[0-9a-f]+$/ }
 
-  specify { expect(junk).to match(hex_regex) }
-  specify { expect(junk.size).to eq(32) }
+  describe "#junk" do
+    it "is a hexadecimal string" do
+      expect(junk).to match hex_regex
+    end
+
+    it "defaults to 32 characters" do
+      expect(junk.size).to eq(32)
+    end
 
-  specify "it is random each time" do
-    expect(subject.junk).to_not eq(subject.junk)
+    it "is random each time" do
+      expect(junk).to_not eq(junk)
+    end
   end
 
   describe "#junk(size)" do
-    let(:junk) { subject.junk 14 }
-
-    specify { expect(junk).to match(hex_regex) }
-    specify { expect(junk.size).to eq(14) }
+    it "emits exactly (size) characters" do
+      expect(junk(14).size).to eq 14
+    end
   end
 
-  describe "#junk(type)" do
-    context "when type is :int" do
-      let(:junk) { subject.junk :int }
-      specify { expect(junk).to be_kind_of(Fixnum) }
+  describe "#junk(:int)" do
+    it "generates a Fixnum" do
+      expect(junk(:int)).to be_a Integer
+    end
 
-      context "with min or max option" do
-        let(:junk) { subject.junk :int, min: 3, max: 5 }
-        it "constrains the value" do
-          expect([3,4,5]).to include(junk)
-        end
-      end
+    context "with min or max option" do
+      let(:val) { junk :int, min: 3, max: 5 }
 
-      context "with size option" do
-        let(:junk) { subject.junk :int, size: 4 }
-        it "constrains the value" do
-          expect((1000..9999)).to include(junk)
-        end
+      it "constrains the value" do
+        expect(val).to be >= 3
+        expect(val).to be <= 5
       end
     end
 
-    context "when type is :bool" do
-      let(:junk) { subject.junk :bool }
+    context "with size option" do
+      let(:val) { junk :int, size: 4 }
 
-      it "returns a boolean" do
-        expect([false, true]).to include(junk)
+      it "generates a number with that many digits (no leading zeroes)" do
+        expect(val).to be >= 1000
+        expect(val).to be <= 9999
       end
     end
+  end
 
-    context "when type is Array or Enumerable" do
-      let(:junk) { subject.junk [:a, :b, 3] }
+  describe "junk(:bool)" do
+    let(:val) { junk :bool }
 
-      specify { expect([:a, :b, 3]).to include(junk) }
+    it "returns a boolean" do
+      expect([false, true]).to include val
     end
+  end
 
-    context "when type is Proc" do
-      let(:junk) { subject.junk ->{ [1,2,3].sample } }
+  describe "junk(<Array>)" do
+    let(:options) { [:a, :b, 3] }
+    let(:val) { junk options }
 
-      specify { expect([1,2,3]).to include(junk) }
+    it "returns an element of the collection" do
+      expect(options).to include val
     end
   end
 
-  context "with exclude option" do
+  describe "junk(<Enumerable>)" do
+    let(:options) { (1..5) }
+    let(:val) { junk options }
+
+    it "returns an element of the collection" do
+      expect(options).to include val
+    end
+
+    it "calls #.to_a on the Enumerable" do
+      # This expectation is included to document that this happens, and could
+      # potentially cause a memory problem. Don't do junk (1..1_000_000_000_000)
+      # unless you're all done with having memory.
+      expect(options).to receive(:to_a).and_call_original
+      expect(options).to include val
+    end
+  end
+
+  describe "junk(<Proc>)" do
+    let(:lambda) { ->{ [1,2,3].sample } }
+    let(:val) { junk lambda }
+
+    it "evaluates the proc" do
+      expect(lambda).to receive(:call).and_call_original
+      expect([1,2,3]).to include val
+    end
+  end
+
+  describe "exclude option" do
+    let(:even_numbers) { [0,2,4,6,8,10] }
+    let(:odd_numbers) { [1,3,5,7,9] }
+
     context "when excluding an item" do
-      let(:junk) { subject.junk :int, max: 1, exclude: 1 }
+      let(:val) { junk :bool, exclude: true }
 
-      specify { expect(junk).to eq(0) }
+      it "excludes the item" do
+        expect(val).to be false
+      end
     end
 
-    context "when excluding an array" do
-      let(:junk) { subject.junk :int, max: 10, exclude: [1,3,5,7,9] }
+    context "when excluding a list" do
+      let(:val) { junk :int, max: 10, exclude: odd_numbers }
 
-      specify { expect([0,2,4,6,8,10]).to include(junk) }
+      it "excludes all of the items" do
+        expect(val).to be_in even_numbers
+      end
     end
 
-    context "when excluding an enumerable" do
-      let(:junk) { subject.junk :int, max: 10, exclude: 1.step(10, 2) }
+    context "when excluding an enumerator" do
+      let(:odd_enum) { 1.step(9, 2) }
+      let(:val) { junk :int, max: 10, exclude: odd_enum }
+
+      it "excludes the elements of the enumerable" do
+        expect(val).to be_in even_numbers
+      end
 
-      specify { expect([0,2,4,6,8,10]).to include(junk) }
+      it "does not call #.to_a on the enumerable to get the complete list" do
+        expect(odd_enum).to_not receive(:to_a)
+        expect(val).to be_in even_numbers
+      end
+
+      it "calls #include? on the enumerable to determine rejection" do
+        expect(odd_enum).to receive(:include?).at_least(:once).and_call_original
+        expect(val).to be_in even_numbers
+      end
     end
 
     context "when excluding a Proc" do
-      let(:junk) { subject.junk :int, max: 10, exclude: ->(x) { x%2==1 } }
-      specify { expect([0,2,4,6,8,10]).to include(junk) }
+      let(:generator) { [1,3,5,6].to_enum }
+      let(:generator_proc) { -> { generator.next } }
+      let(:odd_excluder_proc) { ->(x) { x % 2 == 1 } }
+      let(:val) { junk generator_proc, exclude: odd_excluder_proc }
+
+      it "excludes the candidate if the proc returns true" do
+        expect(val).to eq 6
+      end
+
+      it "passes the junk candidates to the proc" do
+        expect(odd_excluder_proc).to receive(:call).with(1).and_call_original # rejected
+        expect(odd_excluder_proc).to receive(:call).with(3).and_call_original # rejected
+        expect(odd_excluder_proc).to receive(:call).with(5).and_call_original # rejected
+        expect(odd_excluder_proc).to receive(:call).with(6).and_call_original # accepted
+        expect(val).to eq 6
+      end
     end
   end
 
-  context "with format option" do
+  describe "format option" do
     context "when format is :string" do
-      let(:junk) { subject.junk :int, max: 0, format: :string }
+      it "returns the junk cast to a string" do
+        expect(junk [42], format: :string).to eq "42"
+      end
+
+      let(:item) { double }
+      let(:generator) { [item] }
+      let(:val) { junk generator, format: :string }
 
-      specify { expect(junk).to eq("0") }
+      it "sends #to_s to the junk to convert it" do
+        expect(item).to receive(:to_s).and_return "42"
+        expect(val).to eq "42"
+      end
     end
 
+    # Why is this even here, it never gets used...
     context "when format is :int" do
-      let(:junk) { subject.junk ["42"], format: :int }
+      it "returns the junk cast to an integer" do
+        expect(junk ["42"], format: :int).to eq 42
+      end
 
-      specify { expect(junk).to be_kind_of(Integer) }
-      specify { expect(junk).to eq(42) }
+      let(:item) { double }
+      let(:generator) { [item] }
+      let(:val) { junk generator, format: :int }
+
+      it "sends #to_i to the junk to convert it" do
+        expect(item).to receive(:to_i).and_return 42
+        expect(val).to eq 42
+      end
     end
 
-    context "when format is a format string" do
-      let(:junk) { subject.junk [15], format: "0x%02x" }
+    context "when format is a sprintf-style format string" do
+      let(:binary_string) { junk :int, format: "%b" }
 
-      it "formats the value by the string" do
-        expect(junk).to eq("0x0f")
+      it "formats the generated junk with the format string" do
+        expect(binary_string).to match /^[01]+$/
       end
-    end
 
-    context "when format is a Junklet::Formatter" do
-      class HexTripler < RSpec::Junklet::Formatter
-        def value
-          input * 3
+      context "when generator emits an array" do
+        let(:generator) { ->{ [2017, 1, 9] } }
+        let(:val) { junk generator, format: "%d-%02d-%02d" }
+
+        it "passes all of the array elements to the format string" do
+          expect(val).to eq "2017-01-09"
         end
+      end
+    end
 
+    context "when fromat is a custom Junklet::Formatter class" do
+      # By inheriting from Formatter, we get new(input) for free
+      class HexTripler < RSpec::Junklet::Formatter
         def format
-          "0x%02x" % value
+          "0x%02x" % (input * 3)
         end
       end
 
-      let(:junk) { subject.junk [4], format: HexTripler }
+      let(:val) { junk [14], format: HexTripler }
 
-      it "delegates to #format" do
-        expect(junk).to be_kind_of(String)
-        expect(junk).to eq("0x0c")
+      it "passes junk to new and calls format" do
+        expect(val).to eq "0x2a"
       end
     end
 
-    context "when format is a class that quacks like Junklet::Formatter" do
+    context "when format is a any class that implements .new(junk) and #format" do
       class HexDoubler
         def initialize(input)
           @n = input
         end
 
-        def value
-          @n * 2
-        end
-
         def format
-          "0x%04x" % value
+          "0x%02x" % (@n * 2)
         end
       end
 
-      let(:junk) { subject.junk [12], format: HexDoubler }
+      let(:val) { junk [14], format: HexDoubler }
 
-      it "works as expected" do
-        expect(junk).to be_kind_of(String)
-        expect(junk).to eq("0x0018")
+      it "passes junk to new and calls format" do
+        expect(val).to eq "0x1c"
       end
     end
 
-    context "but does not implement #value" do
-      class BadDoublerNoFormat
-        def initialize(input)
-        end
+    context "when format is a Proc" do
+      let(:val) { junk [14], format: ->(x) { x.to_s(2) } }
 
-        def value
-        end
+      it "formats the junk through the proc" do
+        expect(val).to eq "1110"
       end
 
-      let(:junk) { subject.junk [2], format: BadDoublerNoFormat }
-
-      specify { expect { junk }.to raise_error("Formatter class must implement #format method") }
-    end
+      context "when generator emits an array" do
+        let(:generator) { ->{ [2017, 1, 9] } }
+        let(:val) { junk generator, format: ->(x) { "%d-%02d-%02d" % x } }
 
-
-    # BUG: this special case of format does not work:
-    # doubled_string = junk 6, format: ->(x) { x * 2 })
-    # expect(doubled_string.size).to eq(12) # nope, it's 6
-    # junk 6, format: ->(x) { x.upcase } # also returns x unmodified
-
-    context "when format is a Proc" do
-      let(:junk) { subject.junk [3], format: ->(x) { x * 3 } }
-
-      it "calls proc on junk value" do
-        expect(junk).to eq(9)
+        it "passes all of the array elements to the format string" do
+          expect(val).to eq "2017-01-09"
+        end
       end
     end
+  end
 
-    context "when format and exclude are used together" do
-      let(:truth) { subject.junk :bool, format: :string, exclude: "false" }
-      let(:lies) { subject.junk :bool, format: :string, exclude: truth }
+  describe "format and exclude used together" do
+    let(:truth) { junk :bool, format: :string, exclude: "false" }
+    let(:lies) { junk :bool, format: :string, exclude: truth }
 
-      specify "it just works" do
-        expect(truth).to eq("true")
-        expect(lies).to eq("false")
-      end
+    it "applies exclusion after formatting" do
+      expect(truth).to eq("true")
+      expect(lies).to eq("false")
     end
   end
 end

data/spec/lib/rspec/junklet/junklet_spec.rb

@@ -1,40 +1,39 @@
 require PROJECT_ROOT + 'lib/rspec/junklet/junklet'
 
-class JunkletSpy
-  attr_reader :lets
+RSpec.configure do |config|
+  config.extend(RSpec::Junklet::Junklet)    # This lets us say junklet() in describes and contexts
+end
 
-  include ::RSpec::Junklet::Junklet
+describe '.junklet' do
+  junklet :pigs, :cows
 
-  def let(*args)
-    @lets = args
+  it "generates a let" do
+    expect(pigs).to be
+    expect(cows).to be
   end
 
-  def junk
-    'junkety_junky_junk'
+  it "prefixes the let with its own name" do
+    expect(pigs).to match /^pigs_/
+    expect(cows).to match /^cows_/
   end
-end
 
-describe JunkletSpy do
-  specify { expect(subject).to respond_to(:junklet) }
+  it "appends 32 hex characters of random noise to make it unique" do
+    expect(pigs).to match /^pigs_[0-9a-f]{32}$/
+    expect(cows).to match /^cows_[0-9a-f]{32}$/
+  end
 
-  describe '.junklet' do
-    it 'delegates named junklets to let' do
-      expect(subject).to receive(:let).with(:pigs)
-      expect(subject).to receive(:let).with(:cows)
-      subject.junklet :pigs, :cows
-    end
+  describe "separator option" do
+    junklet :pigtruck, separator: '~'
 
-    it 'delegates junk generation to junk' do
-      expect(subject).to receive(:make_junklet).with(:pig_truck, 'pig_truck', '_')
-      expect(subject).to receive(:make_junklet).with(:cow_truck, 'cow_truck', '_')
-      subject.junklet :pig_truck, :cow_truck
+    it 'uses separator instead of underscore' do
+      expect(pigtruck).to match /^pigtruck~/
     end
 
-    context "with separator" do
-      it 'converts separator in name' do
-        expect(subject).to receive(:make_junklet).with(:pig_truck, 'pig~truck', '~')
-        expect(subject).to receive(:make_junklet).with(:cow_truck, 'cow~truck', '~')
-        subject.junklet :pig_truck, :cow_truck, separator: '~'
+    context "when junklet has underscores in its name" do
+      junklet :http_get_param, separator: '-'
+
+      it 'replaces underscores in junklet name as well' do
+        expect(http_get_param).to match /^http-get-param-/
       end
     end
   end

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require_relative PROJECT_ROOT + "lib" + "rspec" + "junklet"
 
 
 require "pry"
+require "byebug"
 
 # Since we've kept rigidly to 80-columns, we can easily
 # Do a pretty side-by-side diff here. This won't handle
@@ -46,3 +47,39 @@ def dump_diff(expected_lines, got_lines)
   end
   dump_footer
 end
+
+# be_in - working inverse of #cover and #include, e.g.
+#
+# let(:range) { (1..5) }
+# let(:list) { [1,2,3,4,5] }
+# let(:val) { 3 }
+#
+# specify { expect(range).to cover val }
+# specify { expect(val).to be_in range }
+# specify { expect(list).to include val }
+# specify { expect(val).to be_in list }
+#
+# Why? Because sometimes I think reading order is important. For example, if the
+# options for a command can vary and we want to assert that they contain a known
+# correct value, I prefer
+#
+# specify { expect(options).to include value }
+#
+# As it is the options that are in question here. But if the list of known
+# options is fixed, and the code under test returns a value that we want to
+# prove is inside the list of known options, I prefer
+#
+# specify { expect(value).to be_in options }
+#
+# ...and yes, I frequently put an #in? method on Object that takes a collection,
+# and simply calls collection.include?(self) internally. Again just because
+# reading order.
+RSpec::Matchers.define :be_in do |list|
+  match do |element|
+    list.include? element
+  end
+end
+
+gem_root = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+Dir[File.join(gem_root, 'spec/support/**/*.rb')].each { |f| require f }

data/spec/support/banner.rb

@@ -0,0 +1,10 @@
+def banner(*objects, &_block)
+  puts '-' * 80
+  if !objects.empty?
+    objects.each do |object|
+      puts object
+    end
+  end
+  yield if block_given?
+  puts '-' * 80
+end

metadata

@@ -1,75 +1,89 @@
 --- !ruby/object:Gem::Specification
 name: rspec-junklet
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.2.1
 platform: ruby
 authors:
 - David Brady
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-05 00:00:00.000000000 Z
+date: 2017-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
 description: Works like let for rspec, but creates unique random junk data
@@ -79,9 +93,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .ruby-version
+- ".gitignore"
+- ".rspec"
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -106,6 +119,7 @@ files:
 - spec/lib/rspec/junklet/junk_spec.rb
 - spec/lib/rspec/junklet/junklet_spec.rb
 - spec/spec_helper.rb
+- spec/support/banner.rb
 homepage: https://github.com/dbrady/rspec-junklet
 licenses:
 - MIT
@@ -116,17 +130,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Easily create junk data for specs
@@ -145,3 +159,4 @@ test_files:
 - spec/lib/rspec/junklet/junk_spec.rb
 - spec/lib/rspec/junklet/junklet_spec.rb
 - spec/spec_helper.rb
+- spec/support/banner.rb

data/.ruby-version

@@ -1 +0,0 @@
-ruby-1.9.3-p551