junklet 1.0.1 → 1.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDBjY2JlZjYxYjAyMjI4NTc0NTBlZDkwZTRjNzdmMjMyZmQwNGMyMQ==
+    Zjc3YzlmNzVjYTc3YmZhNTIwZjZlNTE4Y2I1ZTQ2YWM0ZmNmODk3ZQ==
   data.tar.gz: !binary |-
-    MmRjOTE4OGRiYTA4ODkyYzE3ZTAzNTQ3Y2VjOGYzZDkwZjc0NTY4MA==
+    NTI1YTRjZWJkMmFiMmI3ZWNhOGM2NTBhNDRkZmNjYWZiMzJjNGM4ZQ==
 SHA512:
   metadata.gz: !binary |-
-    NGY2OTMwZGM3NDc5MWI5MzFjYmY2ZTFiZTdjM2VjOTFiMjJiYWVjMjk3N2Fk
-    OWE1MDU2YTc5OWI1M2ZmMjM2YThiMzNiZGMyYTg1MGJkNzNlOTU1NDVjMWEw
-    N2NjMjNjYzE5ZTQyYWNkMGZiNmFkODFhZjkxYzAyNzk4YTNjZmE=
+    OGM0ZDRjYTkxYjdhNTdlNzA5YTM3MjU5MGEyZDk3ZWQwYTQ0YjU5NjczMGE2
+    ZGU0NmIxNjk4ZDc1Yzg5NDAxOTU2NTM4NmJlNTE3NjIwMmM4NWZhMDM2MTNk
+    OTFmN2FiNjAwMThiYTBlNTFkYTM3M2I4NjE5NDQzMDZiZjIxZjk=
   data.tar.gz: !binary |-
-    YjRkMGJhNjdhNzBmMzI4N2U3ZjgwZTVhNjdmODdjNmQxYzg0ZWM1NzBkMzYz
-    NTljODE1NjM4Y2I2YTc0NjEzMjc3MmM3Zjg3M2I1N2NiZDZjODcyZDBjMWM5
-    ODI3MGI1NjQ5ZmQ5MDYyNTM0ODFmY2M4ODdkMWI2MWM0Y2QwZTE=
+    OWIxNDM5ZGUyOWRhODg1YmM5NDFiMWZhMjNjNGY0MTRlZGQ1ZDNmY2JhNGJh
+    Nzk5MzVlZTk4NDJhYWIwM2E0ZDUyNmI1NzEyZGQ2NGIyYjM0M2VhOWM5YTAx
+    MmJiNTg0MGY3ZDY2NGNlNjJlYTU4NmViMmM2OWY5ZmNjZjlhYmU=

data/Gemfile.lock

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

data/README.md

@@ -119,6 +119,49 @@ 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.
 
+
+
+# Finer Control / Custom Types
+
+The `junk` method now has MUCH finer-grained control, though this
+hasn't been pushed up to junklet yet.
+
+
+`junk <type> [options]`
+
+```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(:bool) # returns true or false
+
+junk([:a, :b, :c]) # samples from the Array
+junk(('A'..'Z')) # samples from the range.
+
+# 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.
+
+junk ->{ your_own_random_thing_here }
+
+# 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:
+
+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 }
+
+# And remember that junk is at the same level of precedence as let, so
+# the following ALSO return even numbers:
+
+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) }
+
+```
+
 # TODO
 
 * Formats - The original motivation for Junklet is to encapsulate the

data/lib/junklet/version.rb

@@ -1,3 +1,3 @@
 module Junklet
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/lib/junklet.rb

@@ -5,12 +5,17 @@ module RSpec
     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]) }
+            names = names.map {|name| name.gsub(/_/, opts[:separator])}
           end
 
           args.zip(names).each do |arg, name|
@@ -19,14 +24,84 @@ module RSpec
         end
       end
 
-      def junk(size=32, options={})
-        if :integer == options[:type]
-          # TODO: We can actual know how many hex digits we need in
-          # advance because of te ratio of the logs. We should totally
-          # work that out sometime. The ratio is like 1.2 something. For
-          # now, blah, just make it work.
-          SecureRandom.hex.to_i(16).to_s[0..size]
+      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
+            # Fun fact: you can get back an arbitrarily large number
+            # by specifying a max value >= 2**62 so that Ruby promotes
+            # it to a BigNum.
+            min = opts[:min] || 0
+            max = (opts[:max] || 2**62-2) + 1
+            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

data/spec/lib/junklet_spec.rb

@@ -71,12 +71,80 @@ describe Junklet do
       end
     end
 
-    context "with type: :decimal" do
-      let(:junk_integer) { junk 15, type: :integer }
-      it "returns the request number of decimal digits" do
-        expect { (widget_id).to be_a Integer }
-        expect { (widget_id.to_s.size).to eq(15) }
+    context "with type: array" do
+      let(:junk_ray) { junk [:a, :b, :c] }
+      it "returns a random element of the array" do
+        expect([:a, :b, :c]).to include(junk_ray)
       end
+
+      context "with excludes" do
+        let(:junk_ray) { junk [:a, :b, :c], exclude: [:a, :b] }
+        specify { expect(junk_ray).to eq(:c) }
+      end
+    end
+
+    context "with type: Proc" do
+      let(:junk_proc) { junk(->{ rand(3) }) }
+      specify { expect([0,1,2]).to include(junk_proc) }
+
+      context "with excludes" do
+        let(:junk_proc) { junk(->{ rand(3) }, exclude: [0,2]) }
+        specify { expect(junk_proc).to eq(1) }
+      end
+    end
+
+    context "with type: enumerable" do
+      let(:junk_list) { junk (0..3) }
+      it "returns a random element of the array" do
+        expect([0,1,2,3]).to include(junk_list)
+      end
+    end
+
+    context "with type: :int" do
+      let(:junk_integer) { junk :int }
+      it "returns a random positive Fixnum" do
+        expect { (junk_integer).to be_a Fixnum }
+      end
+
+      context "with min and max values" do
+        let(:coin) { junk :int, min: 0, max: 1 }
+        specify { expect([0,1]).to include(coin) }
+      end
+
+      context "with exclude proc" do
+        let(:junk_evens) { junk :int, min: 0, max: 10, exclude: ->(x) { x % 2 == 1 } }
+        specify { expect(junk_evens % 2).to eq(0) }
+      end
+    end
+
+    context "with type: :bool" do
+      let(:junk_bool) { junk :bool }
+      specify { expect([true, false]).to include(junk_bool) }
+
+      context "with excludes" do
+        let(:junk_bool) { junk :bool, exclude: true }
+        specify { expect(junk_bool).to eq(false) }
+      end
+    end
+
+    # begin
+    #   $caught_bad_junklet_error = false
+    #   junklet :cheesy_bad_junklet, cheese: true
+    # rescue INVALID_JUNKLET_ERROR => e
+    #   raise "junklet got invalid option" unless e.message == "junklet options must be one of #{VALID_JUNKLET_ARGS.map(&:inspect) * ', '}"
+    #   $caught_bad_junklet_error = true
+    # else
+    #   raise "junklet got an invalid argument but didn't catch it" unless $caught_bad_junklet_error
+    # end
+
+    context "with exclude: val" do
+      let(:heads) { 0 }
+      let(:tails) { 1 }
+      let(:coin_heads) { junk :int, max: 1, exclude: tails }
+      let(:coin_tails) { junk :int, max: 1, exclude: heads }
+
+      specify { expect(coin_heads).to eq(heads) }
+      specify { expect(coin_tails).to eq(tails) }
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: junklet
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Dave Brady
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-10 00:00:00.000000000 Z
+date: 2015-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler