Refactor with MapArbitrary

lib/pbt/arbitrary/arbitrary.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # @abstract
+    class Arbitrary
+      # @abstract
+      # @param rng [Random]
+      # @return [Object]
+      def generate(rng)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      # @param current [Object]
+      # @return [Enumerator]
+      def shrink(current)
+        raise NotImplementedError
+      end
+
+      # @param mapper [Proc] a function to map the generated value. it's mainly used for #generate.
+      # @param unmapper [Proc] a function to unmap the generated value. it's used for #shrink.
+      def map(mapper, unmapper)
+        MapArbitrary.new(self, mapper, unmapper)
+      end
+
+      # @param refinement [Proc] a function to filter the generated value and shrunken values.
+      def filter(&refinement)
+        FilterArbitrary.new(self, &refinement)
+      end
+    end
+  end
+end

lib/pbt/arbitrary/arbitrary_methods.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
+require "pbt/arbitrary/arbitrary"
 require "pbt/arbitrary/constant"
 require "pbt/arbitrary/array_arbitrary"
-require "pbt/arbitrary/char_arbitrary"
 require "pbt/arbitrary/integer_arbitrary"
 require "pbt/arbitrary/tuple_arbitrary"
 require "pbt/arbitrary/fixed_hash_arbitrary"
 require "pbt/arbitrary/choose_arbitrary"
 require "pbt/arbitrary/one_of_arbitrary"
-require "pbt/arbitrary/string_arbitrary"
+require "pbt/arbitrary/map_arbitrary"
+require "pbt/arbitrary/filter_arbitrary"
 
 module Pbt
   module Arbitrary
@@ -56,39 +57,39 @@ def one_of(*choices)
 
       # Generates a single unicode character (including printable and non-printable).
       def char
-        CharArbitrary.new
+        choose(0..0x10FFFF).map(CHAR_MAPPER, CHAR_UNMAPPER)
       end
 
       def alphanumeric_char
         one_of(*ALPHANUMERIC_CHARS)
       end
 
       def alphanumeric_string(**kwargs)
-        StringArbitrary.new(array(alphanumeric_char, **kwargs))
+        array(alphanumeric_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
 
       def ascii_char
         one_of(*ASCII_CHARS)
       end
 
       def ascii_string(**kwargs)
-        StringArbitrary.new(array(ascii_char, **kwargs))
+        array(ascii_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
 
       def printable_ascii_char
         one_of(*PRINTABLE_ASCII_CHARS)
       end
 
       def printable_ascii_string(**kwargs)
-        StringArbitrary.new(array(printable_ascii_char, **kwargs))
+        array(printable_ascii_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
 
       def printable_char
         one_of(*PRINTABLE_CHARS)
       end
 
       def printable_string(**kwargs)
-        StringArbitrary.new(array(printable_char, **kwargs))
+        array(printable_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
     end
   end

lib/pbt/arbitrary/array_arbitrary.rb

@@ -2,7 +2,7 @@
 
 module Pbt
   module Arbitrary
-    class ArrayArbitrary
+    class ArrayArbitrary < Arbitrary
       DEFAULT_MAX_SIZE = 10
 
       # @param min_length [Integer]

lib/pbt/arbitrary/choose_arbitrary.rb

@@ -2,7 +2,7 @@
 
 module Pbt
   module Arbitrary
-    class ChooseArbitrary
+    class ChooseArbitrary < Arbitrary
       # @param range [Range<Integer>]
       def initialize(range)
         @range = range

lib/pbt/arbitrary/constant.rb

@@ -11,5 +11,10 @@ module Arbitrary
       *("\u{E000}".."\u{FFFD}"),
       *("\u{10000}".."\u{10FFFF}")
     ].freeze
+
+    CHAR_MAPPER = ->(v) { [v].pack("U") }
+    CHAR_UNMAPPER = ->(v) { v.unpack1("U") }
+    STRING_MAPPER = ->(v) { v.join }
+    STRING_UNMAPPER = ->(v) { v.chars }
   end
 end

lib/pbt/arbitrary/filter_arbitrary.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    class FilterArbitrary < Arbitrary
+      # @param arb [ArrayArbitrary]
+      # @param refinement [Proc] a function to filter the generated value and shrunken values.
+      #
+      def initialize(arb, &refinement)
+        @arb = arb
+        @refinement = refinement
+      end
+
+      # @return [Array]
+      def generate(rng)
+        loop do
+          val = @arb.generate(rng)
+          return val if @refinement.call(val)
+        end
+      end
+
+      # @return [Enumerator]
+      def shrink(current)
+        Enumerator.new do |y|
+          @arb.shrink(current).each do |v|
+            if @refinement.call(v)
+              y.yield v
+            else
+              next
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/pbt/arbitrary/fixed_hash_arbitrary.rb

@@ -2,7 +2,7 @@
 
 module Pbt
   module Arbitrary
-    class FixedHashArbitrary
+    class FixedHashArbitrary < Arbitrary
       # @param hash [Hash<Symbol->Pbt::Arbitrary>]
       def initialize(hash)
         @keys = hash.keys

lib/pbt/arbitrary/integer_arbitrary.rb

@@ -2,7 +2,7 @@
 
 module Pbt
   module Arbitrary
-    class IntegerArbitrary
+    class IntegerArbitrary < Arbitrary
       DEFAULT_TARGET = 0
       DEFAULT_SIZE = 1000000
 

lib/pbt/arbitrary/string_arbitrary.rb → lib/pbt/arbitrary/map_arbitrary.rb

@@ -2,35 +2,27 @@
 
 module Pbt
   module Arbitrary
-    class StringArbitrary
+    class MapArbitrary < Arbitrary
       # @param arb [ArrayArbitrary]
-      def initialize(arb)
+      def initialize(arb, mapper, unmapper)
         @arb = arb
+        @mapper = mapper
+        @unmapper = unmapper
       end
 
       # @return [Array]
       def generate(rng)
-        map(@arb.generate(rng))
+        @mapper.call(@arb.generate(rng))
       end
 
       # @return [Enumerator]
       def shrink(current)
         Enumerator.new do |y|
-          @arb.shrink(unmap(current)).each do |v|
-            y.yield map(v)
+          @arb.shrink(@unmapper.call(current)).each do |v|
+            y.yield @mapper.call(v)
           end
         end
       end
-
-      private
-
-      def map(v)
-        v.join
-      end
-
-      def unmap(v)
-        v.chars
-      end
     end
   end
 end

lib/pbt/arbitrary/one_of_arbitrary.rb

@@ -2,7 +2,7 @@
 
 module Pbt
   module Arbitrary
-    class OneOfArbitrary
+    class OneOfArbitrary < Arbitrary
       # @param choices [Array]
       def initialize(choices)
         @choices = choices

lib/pbt/arbitrary/tuple_arbitrary.rb

@@ -2,7 +2,7 @@
 
 module Pbt
   module Arbitrary
-    class TupleArbitrary
+    class TupleArbitrary < Arbitrary
       # @param arbs [Array<Pbt::Arbitrary>]
       def initialize(*arbs)
         @arbs = arbs

spec/pbt/arbitrary/arbitrary_methods_spec.rb

@@ -1,6 +1,27 @@
 # frozen_string_literal: true
 
 RSpec.describe Pbt::Arbitrary::ArbitraryMethods do
+  describe ".char" do
+    it "generates a character" do
+      val = Pbt.char.generate(Random.new)
+      expect(val).to be_a(String)
+      expect(val.size).to eq(1)
+    end
+
+    describe "#shrink" do
+      it "returns an Enumerator" do
+        arb = Pbt.char
+        val = arb.generate(Random.new)
+        expect(arb.shrink(val)).to be_a(Enumerator)
+      end
+
+      it "returns an Enumerator that iterates characters shrinking towards lower codepoint" do
+        arb = Pbt.char
+        expect(arb.shrink("z").to_a).to eq ["=", "\u001F", "\u0010", "\b", "\u0004", "\u0002", "\u0001", "\u0000"]
+      end
+    end
+  end
+
   describe ".alphanumeric_char" do
     it "generates a character" do
       val = Pbt.alphanumeric_char.generate(Random.new)

spec/pbt/arbitrary/filter_arbitrary_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Pbt::Arbitrary::FilterArbitrary do
+  describe "#initialize" do
+    it do
+      arb = Pbt.integer.filter { |n| n % 2 == 0 }
+      expect(arb).to be_a(Pbt::Arbitrary::FilterArbitrary)
+    end
+  end
+
+  describe "#generate" do
+    it "generates filtered values of given arbitrary" do
+      val = Pbt.integer.filter { |n| n % 2 == 0 }.generate(Random.new)
+      expect(val).to be_even
+    end
+  end
+
+  describe "#shrink" do
+    it "returns an Enumerator" do
+      arb = Pbt.integer.filter { |n| n % 2 == 0 }
+      val = arb.generate(Random.new)
+      expect(arb.shrink(val)).to be_a(Enumerator)
+    end
+
+    it "returns an Enumerator that iterates filtered values" do
+      arb = Pbt.integer.filter { |n| n % 2 == 0 }
+      expect(arb.shrink(50).to_a).to eq [4, 2, 0]
+    end
+
+    context "when current value and target is same" do
+      it "returns an empty Enumerator" do
+        arb = Pbt.integer.filter { |n| n % 2 == 0 }
+        expect(arb.shrink(0).to_a).to eq []
+      end
+    end
+  end
+end