junklet 1.0.3 → 1.0.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTJlN2QwZTEyOGU1OThhMzBmYzMwY2RhYTAzM2E1NzQzNWJhNGM4MQ==
+    MzEzOTFiOWJiOTlhZjEyMGY0MjEzYTk4MzU5ZWVhOWEzZTlhNjg4NA==
   data.tar.gz: !binary |-
-    MjA3MDU1MDhlNzE4YmI2NGJlN2RmYmZjNGU2ZDIxMjIzMmQzMDIxNw==
+    YjM1OTJmZGJhNjhlZmRjM2I3OTU1MzVjOTY3Mjg4OTMxNjFiM2E5OQ==
 SHA512:
   metadata.gz: !binary |-
-    MTg2NTc3MzJmNTBiYmM4OGI4NTZjZGU0MDA3MDgzNjg1NWY4ZDY5MDlmMGQ5
-    Mjc0MGRjYjY0ZWE2N2E1M2ZiM2E1MmVhOTBlYjk3NjdhZWQ4NGQ0YTk5YzQw
-    MDBjZDQxYmI0YzE2NGVkN2RiMmNlY2YwMTFkY2JkMzJmZmU1MGY=
+    ZDBjMGMxYWE3MjI4YzljZWQ2NzQ0ZmNjMWE5ODFjZmQxZDQzOWMzNWI4NWRj
+    NDI5MzA1YzE2MDYzMzI5MGM0YzdmMjZjODlmODY2YzQ5YTE2OWNlNjZmNzMy
+    NTdiZDlmNjU0NDJiNmY5ZmMzMmU0OTZjMGNjMjFkNzEwNzIyZjA=
   data.tar.gz: !binary |-
-    OWNhZDNlNjQ0NmZlNDdmNDg1N2U3YWZlOWMzMjIyNmUzZGY5ZGM0NDJhOWIx
-    OWZiYzk4ZDRjYmRkNTNlZTg0YjM5YmQxZGFlMDgwMGI5N2ZmODZkNGFmODI3
-    YmE5MTZhY2E5ZTAyMjc3NmZlNzYzYWExZDcwOTcwYWEzOTI5NGU=
+    NjYwMjVhOGU4OTUxZjYyMTRjMmI2ZWU0M2ZiZGQ0OTU3YTAyM2M0ZDNlYmQx
+    MmI2NjdhZDA5YzVkMTY1M2EzMWExODdjMDk0MGZlY2VlZDM0OTRlMGJkNjIy
+    MTIyMjUzZWVjNGJlZWY1ZmEyNmIzY2U1MjJlZjBiMWQ5NmUwNDg=

data/Gemfile.lock

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

data/README.md

@@ -18,158 +18,236 @@ So,
 * If equality fails we want to be led to the offending field by the
   error message and not just the line number in the stack trace.
 
-# If You Work At CMM
+## Installation
+
+Add this line to your application's Gemfile:
 
-1. junklet means never having to type SecureRandom again.
-1. junklet prepends the field name to make errors easier to read.
-1. junk() returns a 32-byte random hex number, junk(n) returns the
-   same thing, only n bytes long (can be longer than 32)
+```ruby
+gem 'junklet'
+```
 
-Instead of writing this -> write this:
+And then execute:
 
-* `let(:pants) { SecureRandom.uuid }` -> `junklet :pants`
-* `let(:host_name) { "host-name-#{SecureRandom.uuid}" }` -> `junklet :host_name, separator: '-'` (Remember that underscores aren't legal in host names)
-* `let(:bad_number) { SecureRandom.hex[0..7] }` -> `let(:bad_number) { junk 8 }`
-* `let(:website) { "www.#{SecureRandom.hex}.com" }` -> `let(:website) { "www.#{junk}.com }`
+    $ bundle
 
+Or install it yourself as:
+
+    $ gem install junklet
 
 # Usage
 
+junklet adds two keywords to RSpec's DSL: `junklet`, which defines a
+`let` statement containing junk data, and `junk`, which is a method
+that returns many and varied types of junk data. The former is meant
+to be used as part of the DSL to declare pieces of data to be junk,
+while the latter is intended to be used anywhere inside RSpec to
+supply the junk data itself.
+
+To illustrate, these statements are functionally identically:
+
+```ruby
+junklet :pigtruck
+let(:pigtruck) { junk }
+```
+
+## Junklet
+
+`junklet` declares a memoized variable containing random junk.
+
     junklet :var [, :var_2 [...]] [, options_hash]
 
+So, for example,
+
     junklet :first_name
 
 Creates a `let :first_name` with the value of
 `first_name-774030d0f58d4f588c5edddbdc7f9580` (the hex number is a
-uuid without hyphens and will change with each test case, not just
-each test run)
+uuid without hyphens and will change with each test _case_, not just
+each test run).
 
-    junklet :host_name, separator: '-'
+Currently the options hash only gives you control over the variable
+names appear in the junk data, not the junk data itself. For example,
+
+```ruby
+junklet :host_name, separator: '-'
+```
 
 Creates a `let :host_name`, but changes underscores to hyphens in the
 string value,
 e.g. `host-name-774030d0f58d4f588c5edddbdc7f9580`. Useful
 specifically for host names, which cannot have underscores in them.
 
-    junklet :a_a, :b_b, :c_c, separator: '.'
+```ruby
+junklet :a_a, :b_b, :c_c, separator: '.'
+```
 
 Does what it says on the tin: creates 3 items with string values of
-`a.a`, `b.b`, and `c.c` respectively.
+`a.a.774...`, `b.b.1234...`, and `c.c.234abc...` respectively. I don't
+know why you'd need this, but hey, if you do there it is.
 
+## Junk
 
-    junk [length=32]
+`junk` returns random junk, which can be finely tuned and fiddled with.
 
-Can be called from inside a spec or let block, and returns a random
-hex string 32 bytes long (or whatever length you specify)
+```ruby
+junk
+junk (integer|symbol|enumerable|proc) [options]
+```
 
-# Background
+By default, just calling `junk` from inside a spec or let block
+returns a random hex string 32 bytes long.
 
-At CoverMyMeds we have a legacy impingement that prevents us sometimes
-from clearing out data from previous test runs. As a result we often
-have required fields in tests that must be unique but are tested
-elsewhere, so we don't really care about them in the current test
-run. For the current test we just want to stub out that field with
-something unique but we also want to communicate to the developer that
-the contents of the field are not what we currently care about.
+### integer
+
+Give junk an integer argument and it will return that many hexadecimal
+digits of junk data. Note that this is HALF the number of digits
+returned if you were to call `SecureRandom.hex(n)`, because `hex(n)`
+returns n _bytes_, each of which requires two hex digits to
+represent. Since we're more concerned about specific byte lengths,
+`junk(n)` gives you n digits, not n*2 digits representing n bytes.
 
-Currently we do this with `SecureRandom.uuid`, so we'll see code like
-this frequently in RSpec:
 
 ```ruby
-let(:first_name) { SecureRandom.uuid }
-let(:last_name) { SecureRandom.uuid }
-let(:address) { SecureRandom.uuid }
-let(:city) { SecureRandom.uuid }
-let(:state) { SecureRandom.uuid }
-let(:phone) { SecureRandom.uuid }
+junk 17 - return 17 bytes of junk data
 ```
 
-...etc. Later in the spec we'll often test against those stubs,
-e.g. with `expect(user.first_name).to eq(first_name)` but this idiom
-expresses that we only care about the equality, not the actual
-contents.
+### symbol
 
-Junklet seeks to improve the readability and conciseness of this
-intention. One thing that bugs me about the above approach is that if
-a weird regression bug appears and an unimportant field is the source
-of a crash. So with Junklet I also wanted to add the ability to call
-out the offending field by name. In theory we could just write
-`let(:first_name) { 'first_name-' + SecureRandom.uuid }` but in
-practice that creates duplication in the code and muddies the original
-idiom of "uncared-about" data.
+junk may be given a symbol denoting the type of data to be
+returned. Currently `:int` and `:bool` are the only supported
+types. `junk :bool` merely returns true or false; `junk :int` is
+much more complicated and interesting.
 
-Enter Junklet:
+```ruby
+junk :bool # Boring. Well, 50% chance of boring.
+```
+
+
+`junk :int` is the most complicated and/or interesting type of
+junk. It returns a random decimal number, and it has the most options
+such as `size` (number of digits), and `min` and `max` (which sort of
+do what you'd expect).
+
+By default, `junk :int` returns a random number from 0 to the largest
+possible `Fixnum`, which is 2**62-1.
 
 ```ruby
-junklet :first_name
-junklet :last_name
-junklet :address
-junklet :city
-junklet :state
-junklet :phone
+junk :int # return a random integer from 0 to 2**62-1 (maximum size of
+a Fixnum)
 ```
 
-Or, if you don't want the junklets to sprawl vertically,
+`size`, `min` and `max` control the size and bounds of the random
+number.
 
 ```ruby
-junklet :first_name, :last_name, :address, :city, :state, :phone
+junk :int, size: 3 # returns a 3-digit decimal from 100 to 999.
+junk :int, max: 10 # returns a random number from 0 to 10.
+junk :int, min: 100 # returns a random number from 100 to 2**62-1.
 ```
 
-This will have the same effect as calling `let` on the named fields
-and setting the fieldname and a 32-byte hex string (a uuid with
-hyphens removed) to be the memoized value.
+Note: You can mix size with min or max, but they can only be used to
+further restrict the range, not expand it, because that would change
+the size constraint. So these examples work the way you'd expect:
 
+```ruby
+junk :int, size: 4, min: 2000 # random number 2000-9999
+junk :int, size: 4, max: 2000 # random number 1000-2000
+```
 
+But in these examples, `min` and `max` have no effect:
 
-# Finer Control / Custom Types
+```ruby
+junk :int, size: 2, min: 0 # nope, still gonna get 10-99
+junk :int, size: 2, max: 200 # nope, still gonna get 10-99
+```
 
-The `junk` method now has MUCH finer-grained control, though this
-hasn't been pushed up to junklet yet.
+Technically, you can use BOTH `min` and `max` with `size` to constrain
+both bounds of the number, but this effectively makes the `size`
+option redundant. It will work correctly, but if you remove the size
+constraint you'll still get the same exact range:
 
+```ruby
+# Don't do this
+junk :int, size: 3, min: 125, max: 440 # 125-440. size is now redundant.
+```
 
-`junk <type> [options]`
+### Array / Enumerable
+
+If you give junk an `Array`, `Range`, or any other object that
+implements `Enumerable`, it will select an element at random from the
+collection.
 
 ```ruby
-junk(:int) # returns a random, positive ruby Fixnum between 0 and
-           # 2**62-1.
-junk(:int, min: 5, max: 9) # returns a number from 5 to 9
-junk(:int, max: 1) # returns 0 or 1
+junk [1,3,5,7,9] # pick a 1-digit odd number
+junk (1..5).map {|x| x*2-1 } # pick a 1-digit odd number while trying way too hard
+junk (1..9).step(2) # pick a 1-digit odd number, but now I'm just showing off
+```
 
-# If you just know how many digits you need, use size:
+*IMPORTANT CAVEAT*: the Enumerable forms all use `.to_a.sample` to get
+the random value, and `.to_a` will cheerfully exhaust all the memory
+Ruby has if you use it on a sufficiently large array.
 
-junk(:int, size: 3) # generates number between 100 and 999
+*LESS-IMPORTANT CAVEAT*: Technically anything that can be converted to
+ an array and then sampled can go through here, so `words.split` would
+ do what you want, but remember that hashes get turned into an array
+ of _pairs_, so expect this weirdness if you ask for it:
 
-# min and max can further constrain size (but not expand it):
-junk(:int, size: 3, min: 425) # number from 425 to 999
-junk(:int, size: 3, max: 425) # number from 100 to 425
+```ruby
+junk({a: 42, b: 13}) # either [:a, 42] or [:b, 13]
+```
 
-junk(:bool) # returns true or false
+### Proc
 
-junk([:a, :b, :c]) # samples from the Array
-junk(('A'..'Z')) # samples from the range.
+When all else fails, it's time to haul out the lambdas, amirite? The
+first argument ot `junk` can be a proc that yields the desired random
+value. Let's get those odd numbers again:
 
-# Memory warning: calls to_a on range first, so if you want a number
-# from 100000 to 999999, favor junk(:int, min: 100000, max: 999999)
-# instead.
+```ruby
+junk ->{ rand(5)*2 + 1 } # 1-digit odd number
+```
 
-junk ->{ your_own_random_thing_here }
+### Other Options
 
-# Also note that all types also take an `exclude` option, which can be
-# a value, an array, or a proc. These all return even numbers:
+### Exclude
 
-junk :int, min: 2, max:   4, exclude: 3
-junk :int, min: 2, max:  10, exclude: [3,5,7,9]
-junk :int, min: 2, max: 100, exclude: ->(x) { x % 2 == 1 }
+Besides the options that `:int` will take, all of the types will
+accept an `exclude` argument. This is useful if you want to generate
+more than one piece of junk data and ensure that they are
+different. The exclude option can be given a single element, an array,
+or an enumerable, and if all that fails you can give it a proc that
+accepts the generated value and returns true if the value should be
+excluded. Let's use all these excludes to generate odd numbers again:
 
-# And remember that junk is at the same level of precedence as let, so
-# the following ALSO return even numbers:
+```ruby
+junk :int, min: 1, max: 3, exclude: 2 # stupid, but it works
+junk (1..9), exclude: [2,4,6,8]
+junk (1..9), exclude: (2..8) # okay, only returns 1 or 9 but hey,
+                             # they're both odd
+junk :int, exclude: ->(x) { x % 2 == 0 } # reject even numbers
+```
+But again, the real advantage is being able to avoid collisions:
 
-let(:three) { 3 }
-let(:evens) { junk :int, min: 2, max:   4, exclude: three }
-let(:two_or_four) { junk :int, min: 2, max:   4, exclude: ->(x){ !evens.include?(x) }
+```ruby
+let(:id1) { junk (0..9) }
+let(:id2) { junk (0..9), exclude: id1 }
+let(:id3) { junk (0..9), exclude: [id1, id2] }
 
+let(:coinflip) { junk :bool }
+let(:otherside) { junk :bool, exclude: coinflip } # Look I never said
+    # all of these were great ideas, I'm just saying you can DO them.
 ```
 
+*VERY IMPORTANT CAVEAT* If you exclude all of the possibilities from
+the random key space, junk will cheerfully go into an infinite
+loop.
+
+### Format
+
+Coming soon! I currently have need of the ability to generate decimal
+numbers but then left-pad them with zeros and represent them as
+strings. Can do it with lambdas, but some standard formatting would be
+really nice.
+
 # TODO
 
 * Formats - The original motivation for Junklet is to encapsulate the
@@ -204,21 +282,62 @@ let(:two_or_four) { junk :int, min: 2, max:   4, exclude: ->(x){ !evens.include?
   RSpec 2. Remember kids, "Enterprise" means "most of our money comes
   from the legacy platform".
 
-## Installation
+# Background
 
-Add this line to your application's Gemfile:
+At CoverMyMeds we have a legacy impingement that prevents us sometimes
+from clearing out data from previous test runs. As a result we often
+have required fields in tests that must be unique but are tested
+elsewhere, so we don't really care about them in the current test
+run. For the current test we just want to stub out that field with
+something unique but we also want to communicate to the developer that
+the contents of the field are not what we currently care about.
+
+Currently we do this with `SecureRandom.uuid`, so we'll see code like
+this frequently in RSpec:
 
 ```ruby
-gem 'junklet'
+let(:first_name) { SecureRandom.uuid }
+let(:last_name) { SecureRandom.uuid }
+let(:address) { SecureRandom.uuid }
+let(:city) { SecureRandom.uuid }
+let(:state) { SecureRandom.uuid }
+let(:phone) { SecureRandom.uuid }
 ```
 
-And then execute:
+...etc. Later in the spec we'll often test against those stubs,
+e.g. with `expect(user.first_name).to eq(first_name)` but this idiom
+expresses that we only care about the equality, not the actual
+contents.
 
-    $ bundle
+Junklet seeks to improve the readability and conciseness of this
+intention. One thing that bugs me about the above approach is that if
+a weird regression bug appears and an unimportant field is the source
+of a crash. So with Junklet I also wanted to add the ability to call
+out the offending field by name. In theory we could just write
+`let(:first_name) { 'first_name-' + SecureRandom.uuid }` but in
+practice that creates duplication in the code and muddies the original
+idiom of "uncared-about" data.
 
-Or install it yourself as:
+Enter Junklet:
 
-    $ gem install junklet
+```ruby
+junklet :first_name
+junklet :last_name
+junklet :address
+junklet :city
+junklet :state
+junklet :phone
+```
+
+Or, if you don't want the junklets to sprawl vertically,
+
+```ruby
+junklet :first_name, :last_name, :address, :city, :state, :phone
+```
+
+This will have the same effect as calling `let` on the named fields
+and setting the fieldname and a 32-byte hex string (a uuid with
+hyphens removed) to be the memoized value.
 
 ## Contributing
 

data/lib/junklet.rb

@@ -1,127 +1,9 @@
 require "junklet/version"
+require "junklet/junk"
+require "junklet/junklet"
 
-module RSpec
-  module Core
-    module MemoizedHelpers
-      module ClassMethods
-        def junklet(*args)
-          # TODO: figure out how to use this to wrap junk in junklet,
-          # so that junklet can basically have all the same options as
-          # junk does. E.g. junklet :ddid, :pcn, :group, type: :int,
-          # min: 100000, max: 999999, etc, and you'd get back 3
-          # junklets of 6-digit numbers.
-          opts = args.size > 1 && !args.last.is_a?(Symbol) && args.pop || {}
-
-          names = args.map(&:to_s)
-
-          if opts.key?(:separator)
-            names = names.map {|name| name.gsub(/_/, opts[:separator])}
-          end
-
-          args.zip(names).each do |arg, name|
-            let(arg) { "#{name}-#{junk}" }
-          end
-        end
-      end
-
-      def junk(*args)
-        # TODO: It's long past time to extract this....
-
-        # args.first can be
-        # - an integer indicating the size of the hex string to return
-        # - a symbol denoting the base type, e.g. :int
-        # - an array to sample from
-        # - a range or Enumerable to sample from. WARNING: will call
-        #   .to_a on it first, which might be expensive
-        # - a generator Proc which, when called, will generate the
-        #   value to use.
-        #
-        # args.rest is a hash of options:
-        # - sequence: Proc or Array of values to choose from.
-        # - exclude: value, array of values, or proc to exclude. If a
-        #   Proc is given, it takes the value generated and returns
-        #   true if the value should be excluded.
-        #
-        # - for int:
-        #   - min: minimum number to return. Default: 0
-        #   - max: upper limit of range
-        #   - exclude: number, array of numbers, or proc to
-        #     exclude. If Proc is provided, tests the number against
-        #     the Proc an excludes it if the Proc returns true. This
-        #     is implemented except for the proc.
-
-        # 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
-        # FIXME: If arg 2 present, Raise Argument error unless it's a
-        #        hash.
-        # FIXME: Figure out what our valid options are and parse them;
-        #        raise errors if present.
-
-        classes = [Symbol, Array, Enumerable, Proc]
-        if args.size > 0 && classes.any? {|klass| args.first.is_a?(klass) }
-          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
-                       ->(x) { false }
-                     end
-
-          # TODO: Refactor me. Seriously, this is a functional
-          # programming version of the strategy pattern. Wouldn't it
-          # be neat if we had some kind of object-oriented language
-          # available here?
-          case type
-          when :int
-            # min,max cooperate with size to further constrain it. So
-            # size: 2, min: 30 would be min 30, max 99.
-            if opts[:size]
-              sized_min = 10**(opts[:size]-1)
-              sized_max = 10**opts[:size]-1
-            end
-            explicit_min = opts[:min] || 0
-            explicit_max = (opts[:max] || 2**62-2) + 1
-
-            if sized_min
-              min = [sized_min, explicit_min].max
-              max = [sized_max, explicit_max].min
-            else
-              min = sized_min || explicit_min
-              max = sized_max || explicit_max
-            end
-
-            min,max = max,min if min>max
-
-            generator = -> { rand(max-min) + min }
-          when :bool
-            generator = -> { [true, false].sample }
-          when Array, Enumerable
-            generator = -> { type.to_a.sample }
-          when Proc
-            generator = type
-          else
-            raise "Unrecognized junk type: '#{type}'"
-          end
-
-          begin
-            val = generator.call
-          end while excluder.call(val)
-          val
-        else
-          size = args.first.is_a?(Numeric) ? args.first : 32
-          # hex returns size*2 digits, because it returns a 0..255 byte
-          # as a hex pair. But when we want junt, we want *bytes* of
-          # junk. Get (size+1)/2 chars, which will be correct for even
-          # sizes and 1 char too many for odds, so trim off with
-          # [0...size] (note three .'s to trim off final char)
-          SecureRandom.hex((size+1)/2)[0...size]
-        end
-      end
-    end
-  end
+RSpec.configure do |config|
+  config.extend(Junklet::Junklet)
+  config.extend(Junklet::Junk) # when metaprogramming cases, you may need junk in ExampleGroups
+  config.include(Junklet::Junk)
 end

data/lib/junklet/junk.rb

@@ -0,0 +1,102 @@
+module Junklet
+  module Junk
+    def junk(*args)
+      # TODO: It's long past time to extract this....
+
+      # args.first can be
+      # - an integer indicating the size of the hex string to return
+      # - a symbol denoting the base type, e.g. :int
+      # - an array to sample from
+      # - a range or Enumerable to sample from. WARNING: will call
+      #   .to_a on it first, which might be expensive
+      # - a generator Proc which, when called, will generate the
+      #   value to use.
+      #
+      # args.rest is a hash of options:
+      # - sequence: Proc or Array of values to choose from.
+      # - exclude: value, array of values, or proc to exclude. If a
+      #   Proc is given, it takes the value generated and returns
+      #   true if the value should be excluded.
+      #
+      # - for int:
+      #   - min: minimum number to return. Default: 0
+      #   - max: upper limit of range
+      #   - exclude: number, array of numbers, or proc to
+      #     exclude. If Proc is provided, tests the number against
+      #     the Proc an excludes it if the Proc returns true. This
+      #     is implemented except for the proc.
+
+      # 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
+      # FIXME: If arg 2 present, Raise Argument error unless it's a
+      #        hash.
+      # FIXME: Figure out what our valid options are and parse them;
+      #        raise errors if present.
+
+      classes = [Symbol, Array, Enumerable, Proc]
+      if args.size > 0 && classes.any? {|klass| args.first.is_a?(klass) }
+        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
+                     ->(x) { false }
+                   end
+
+        # TODO: Refactor me. Seriously, this is a functional
+        # programming version of the strategy pattern. Wouldn't it
+        # be neat if we had some kind of object-oriented language
+        # available here?
+        case type
+        when :int
+          # min,max cooperate with size to further constrain it. So
+          # size: 2, min: 30 would be min 30, max 99.
+          if opts[:size]
+            sized_min = 10**(opts[:size]-1)
+            sized_max = 10**opts[:size]-1
+          end
+          explicit_min = opts[:min] || 0
+          explicit_max = (opts[:max] || 2**62-2) + 1
+
+          if sized_min
+            min = [sized_min, explicit_min].max
+            max = [sized_max, explicit_max].min
+          else
+            min = sized_min || explicit_min
+            max = sized_max || explicit_max
+          end
+
+          min,max = max,min if min>max
+
+          generator = -> { rand(max-min) + min }
+        when :bool
+          generator = -> { [true, false].sample }
+        when Array, Enumerable
+          generator = -> { type.to_a.sample }
+        when Proc
+          generator = type
+        else
+          raise "Unrecognized junk type: '#{type}'"
+        end
+
+        begin
+          val = generator.call
+        end while excluder.call(val)
+        val
+      else
+        size = args.first.is_a?(Numeric) ? args.first : 32
+        # hex returns size*2 digits, because it returns a 0..255 byte
+        # as a hex pair. But when we want junt, we want *bytes* of
+        # junk. Get (size+1)/2 chars, which will be correct for even
+        # sizes and 1 char too many for odds, so trim off with
+        # [0...size] (note three .'s to trim off final char)
+        SecureRandom.hex((size+1)/2)[0...size]
+      end
+    end
+  end
+end

data/lib/junklet/junklet.rb

@@ -0,0 +1,21 @@
+module Junklet
+  module Junklet
+    def junklet(*args)
+      # TODO: figure out how to use this to wrap junk in junklet,
+      # so that junklet can basically have all the same options as
+      # junk does. E.g. junklet :ddid, :pcn, :group, type: :int,
+      # min: 100000, max: 999999, etc, and you'd get back 3
+      # junklets of 6-digit numbers.
+      opts = args.size > 1 && !args.last.is_a?(Symbol) && args.pop || {}
+
+      names = args.map(&:to_s)
+
+      separator = opts[:separator] || '_'
+      names = names.map {|name| name.gsub(/_/, separator)}
+
+      args.zip(names).each do |arg, name|
+        let(arg) { "#{name}#{separator}#{junk}" }
+      end
+    end
+  end
+end

data/lib/junklet/version.rb

@@ -1,3 +1,3 @@
 module Junklet
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/spec/lib/junklet_spec.rb

@@ -10,7 +10,7 @@ describe Junklet do
       junklet :trash
 
       specify { expect(trash).to be }
-      specify { expect(trash).to match /^trash-/ }
+      specify { expect(trash).to match /^trash_/ }
       specify { expect(trash).to match hex_regex }
 
       describe "memoization" do
@@ -21,23 +21,24 @@ describe Junklet do
     context "with multiple args" do
       junklet :trash, :toss, :crud, :crap
 
-      specify { expect(trash).to match /^trash-/ }
+      specify { expect(trash).to match /^trash_/ }
       specify { expect(trash).to match hex_regex }
-      specify { expect(toss).to match /^toss-/ }
+      specify { expect(toss).to match /^toss_/ }
       specify { expect(toss).to match hex_regex }
-      specify { expect(crud).to match /^crud-/ }
+      specify { expect(crud).to match /^crud_/ }
       specify { expect(crud).to match hex_regex }
-      specify { expect(crap).to match /^crap-/ }
+      specify { expect(crap).to match /^crap_/ }
       specify { expect(crap).to match hex_regex }
     end
 
     context 'with separator option' do
-      junklet :host_name, :last_name, :first_name, separator: '-'
+      junklet :host_name, separator: '-'
+      junklet :last_name, :first_name, separator: '.'
       specify { expect(host_name).to match /^host-name-/ }
       specify { expect(host_name).to match hex_regex }
-      specify { expect(last_name).to match /^last-name-/ }
+      specify { expect(last_name).to match /^last\.name\./ }
       specify { expect(last_name).to match hex_regex }
-      specify { expect(first_name).to match /^first-name-/ }
+      specify { expect(first_name).to match /^first\.name\./ }
       specify { expect(first_name).to match hex_regex }
     end
   end
@@ -152,4 +153,11 @@ describe Junklet do
       specify { expect(coin_tails).to eq(tails) }
     end
   end
+
+  context "metaprogramming use cases" do
+    metaname = junk
+    describe "works by allowing junk to be set from an ExampleGroup outside of an ExampleCase" do
+      specify { expect(metaname).to be }
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: junklet
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Dave Brady
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,6 +96,8 @@ files:
 - README.md
 - junklet.gemspec
 - lib/junklet.rb
+- lib/junklet/junk.rb
+- lib/junklet/junklet.rb
 - lib/junklet/version.rb
 - lib/line.rb
 - spec/fixtures/block1_after.txt