rspec-junklet 1.1.0 → 1.1.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZWQwYjZkZmNlNjlkNmM0MTE2YTMyNzBmYTEwMjU0MThjMjNlYzUzMA==
+    ZGY1MjM2NDliN2U1MWUxYTc0ZWQzYmM1YzgwY2EwOWZmYTI0NmIyMg==
   data.tar.gz: !binary |-
-    MjQwNmUwNzQxYTljYWQ1NjhiMTgxNzU0NTk0NzNjNTk4MDhkYjdkNg==
+    ZTRmMGFmMWM3MzVkNjQ4N2Q2MmQ1M2U1OTg5ZThhODgyMDQxMGI0MQ==
 SHA512:
   metadata.gz: !binary |-
-    ZTFlNmUzYTRhNzgzNjQyNjViZjA4YWNmYzI5Mjk4NWQ3N2VmNDhkYjZmNzIx
-    NmM5MWE5MDkzNzk1Y2E2YmM2MTEyM2U2YWI0YTU4NjVkOTA1MTdiYjNhZGFj
-    MThhZjU2MWY2ZDRhYTI2ODQ4MTI2YzJkZmM1NTM0ODJiM2Q1YmQ=
+    ZDU5OTYxZGQwMmY3NWQ1MDM2NDU5MTU3ODA2NzE3OTJhMWMzNTM4OGM2YWVj
+    MTE5NTE2MTY4OTZjYTcxMDQ2ZDQ2YTdlOTdjZWUwNmI0ZTRiMDQ2N2M1MjY5
+    MjBlYmUxMGJiNmY5ZjlmOGNkYzMxZjE3NjIwMjdiNzJhY2FjNDg=
   data.tar.gz: !binary |-
-    OWY2NjNiNmY2ZDM1NTVlNWNmODNmZDIxMGNjODI1N2Y2M2MzMmJkOWY4Nzc4
-    NDY1NTFjZmFjZjU1NjA2YmJiZWI3NzUyYzQ0ZjZmZjYxNjIxYmJlMThkM2Y5
-    OTYyMjA0ZjEwMTk5MGU1ZmQ2N2UxYWZjMmVlYjQyZWEyZWM4NDQ=
+    MWNlM2E0NzAyNWVhODBkMDBmMjljZDc0MDNkZjViMTZkMTc3ZjRkOWJlYmIw
+    ZGJiZWJhZGNjZGQ1MjdiMzBlMjRhZmI4YmJjNDhlZmFhYzEzOWE3YjZiMTcw
+    OGYwY2IzYzkwNDE5YTMwZGUwMDdjYTYzNTExNDBmMzM5YTI3NmE=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rspec-junklet (1.0.4)
+    rspec-junklet (1.1.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -232,17 +232,87 @@ key space, junk will cheerfully go into an infinite loop.
 
 ### Format
 
-Formats are here, but need documentating! For now: `format: :int` will cast your
-junk to an integer by calling `.to_i` on it. Other formats include:
+A format can be applied to junk data after generation. This lets you change the
+class or representation of the junk. For example, this feature was added because
+we needed 6-digit decimal ids... represented as strings. Originally I wrote
+
+```ruby
+let(:drug_id) { junk( ->{ junk(:int, size: 6).to_s } ) }
+```
+
+But now I can just say
+
+```ruby
+let(:drug_id) { junk(:int, size: 6, format: :string) }
+```
+Here are the available formats:
 
 * `format: :int` calls `.to_i` on the junk before returning it
 * `format: :string` calls `.to_s` on the junk
 * `format: "%s"` (or any other string) calls sprintf on the junk with the
   string as the format string
 * `format: SomeClass` passes the junk to `SomeClass.new`, returning an instance
-  of `SomeClass`. *Note:* If you plan on combining this with `exclude`, make
-  sure your class implements the `==` operator.
-* `format: ->(x) { ... }` passes the junk to your Proc
+  of `SomeClass`. *Important:* This class must implement a `#format` method
+  which returns the formatted junk. See the `::Junklet::Formatter` class for an
+  example class that simply returns the unmodified junk.
+* `format: ->(x) { ... }` passes the junk to your Proc; whatever you return is
+  the value of the junk. This is obviously the most powerful transform as it can
+  return anything at all; there's nothing stopping you from using the format
+  proc as the generator itself aside from the constraints of good taste. ;-) If
+  you _were_ to exhibit poor taste, one conceivable (yet still very strained)
+  example might be `junk :int, format: ->(x) { srand(x); rand }` but it's not
+  really a very far stretch to generate, say, a random index in the generator
+  and use the formatter to map it to a dictionary word or some other very wild
+  transformation.
+
+### Formatter Classes
+
+The careful reader will have noted by now that you can pass a class name as a
+format. This is intended to be a Formatter class. A Formatter class takes the
+generated junk in its initialize method. If the class implements `#format`, this
+method will be called and the return value of this method will be the junk
+data. If the class does not implement `#format`, the Formatter object itself
+will be returned and you can use it how you see fit. It's probably a good idea
+to implement `#to_s` if your formatter is going to wind up in a string
+somewhere.
+
+So for example, let's say you want to generate a ZIP+4 code. That's a 5-digit
+decimal number, a hyphen, and a 4-digit decimal. This whole mess is then
+represented as a string. You could do this with a simple lambda:
+
+```ruby
+let(:zip) { junk :int, size: 9, format: ->(x) { '%d-%d' % [x/10000, x%10000] } }
+```
+
+...but if you're going to be generating ZIP codes regularly, a formatter class
+is probably in order:
+
+```ruby
+class Format::ZipCode
+  attr_reader :code
+  def initialize(code)
+    @code = code
+  end
+
+  def format
+    '%d-%d' % [x/10000, x%10000]
+  end
+end
+```
+
+Now your junk uses the class as designed:
+
+```ruby
+let(:zip) { junk :int, size: 9, format: Format::ZipCode }
+```
+
+TODO: Hrm, if I'm going to do to that much trouble, why not have an entire junk
+generation class? E.g. include the generator with the formatter, so that we can
+just say
+
+```ruby
+let(:zip) { junk ZipCode }
+```
 
 # TODO
 

data/lib/junklet/formatter.rb

@@ -0,0 +1,14 @@
+module Junklet
+  class Formatter
+    attr_reader :input
+
+    def initialize(input)
+      @input = input
+    end
+
+    # You probably want to override this
+    def format
+      input
+    end
+  end
+end

data/lib/junklet/junk.rb

@@ -1,3 +1,5 @@
+require_relative 'formatter'
+
 module Junklet
   module Junk
     def junk(*args)
@@ -26,6 +28,26 @@ module Junklet
       #     the Proc an excludes it if the Proc returns true. This
       #     is implemented except for the proc.
 
+      # FIXME: Would be nice to be able to say, e.g. `junk exclude: bob` but
+      #        currently this breaks because {exclude: bob} is a Hash which is
+      #        an Enumerable which means it's a valid generator. I don't want to
+      #        just disallow hashes as generators here. What's a good workaround
+      #        for when I really do just want junk with either a format or an
+      #        exclusion? `junk :junk, exclude: bob` looks bad. `junk _,
+      #        exclude: bob` is also pretty bad.
+      #
+      #        Hmm, I'm tempted to say "the one enumerable you CAN'T have is a
+      #        Hash, so it can be the options hash; if you DO want to pass in a
+      #        hash, you must cast it to an array or yield it from a Proc
+      #        instead". Given that the hash case is weird and rare enough, I
+      #        think this is acceptable. Oh, if only I didn't have to maintain
+      #        backwards compatibility with older Rubies, I could just make
+      #        these keyword args. Sigh.
+
+      # FIXME: This whole darn method is outta control, and for the record none
+      #        of the cool excluders and formatters work with the
+      #        SecureRandom.hex default. Barf.
+
       # FIXME: Raise Argument error unless *args.size is 0-2
       # FIXME: If arg 1 is a hash, it's the options hash, raise
       #        ArgumentError unless args.size == 1
@@ -54,10 +76,12 @@ module Junklet
                       ->(x) { x.to_s }
                     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) }
-                    when Class
-                      ->(x) { opts[:format].new(x) }
                     when Proc
                       opts[:format]
                     else

data/lib/junklet/version.rb

@@ -1,3 +1,3 @@
 module Junklet
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

data/spec/lib/junklet/junk_spec.rb

@@ -113,24 +113,63 @@ describe JunkSpy do
       end
     end
 
-    context "when format is a class" do
-      class Doubler
-        def initialize(n)
-          @n = n
+    context "when format is a Junklet::Formatter" do
+      class HexTripler < Junklet::Formatter
+        def value
+          input * 3
+        end
+
+        def format
+          "0x%02x" % value
+        end
+      end
+
+      let(:junk) { subject.junk [4], format: HexTripler }
+
+      it "delegates to #format" do
+        expect(junk).to be_kind_of(String)
+        expect(junk).to eq("0x0c")
+      end
+    end
+
+    context "when format is a class that quacks like Junklet::Formatter" do
+      class HexDoubler
+        def initialize(input)
+          @n = input
         end
+
         def value
           @n * 2
         end
+
+        def format
+          "0x%04x" % value
+        end
       end
 
-      let(:junk) { subject.junk [3], format: Doubler }
+      let(:junk) { subject.junk [12], format: HexDoubler }
 
-      it "instantiates class with junk value" do
-        expect(junk).to be_kind_of(Doubler)
-        expect(junk.value).to eq(6)
+      it "works as expected" do
+        expect(junk).to be_kind_of(String)
+        expect(junk).to eq("0x0018")
       end
     end
 
+    context "but does not implement #value" do
+      class BadDoublerNoFormat
+        def initialize(input)
+        end
+
+        def value
+        end
+      end
+
+      let(:junk) { subject.junk [2], format: BadDoublerNoFormat }
+
+      specify { expect { junk }.to raise_error("Formatter class must implement #format method") }
+    end
+
+
     context "when format is a Proc" do
       let(:junk) { subject.junk [3], format: ->(x) { x * 3 } }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-junklet
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - David Brady
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-20 00:00:00.000000000 Z
+date: 2015-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,6 +95,7 @@ files:
 - LICENSE
 - README.md
 - lib/junklet.rb
+- lib/junklet/formatter.rb
 - lib/junklet/junk.rb
 - lib/junklet/junklet.rb
 - lib/junklet/version.rb