pbt 0.0.1 → 0.1.0

data/lib/pbt/arbitrary/arbitrary_methods.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require "pbt/arbitrary/arbitrary"
+require "pbt/arbitrary/constant"
+require "pbt/arbitrary/constant_arbitrary"
+require "pbt/arbitrary/array_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/map_arbitrary"
+require "pbt/arbitrary/filter_arbitrary"
+
+module Pbt
+  module Arbitrary
+    module ArbitraryMethods
+      # For integers between min (included) and max (included).
+      #
+      # @param min [Integer] Lower limit for the generated integers (included).
+      # @param max [Integer] Upper limit for the generated integers (included).
+      # @return [Arbitrary<Integer>]
+      def integer(min: -1000000, max: 1000000)
+        IntegerArbitrary.new(min, max)
+      end
+
+      # For natural numbers (non-negative integers) between 0 (included) and max (included).
+      #
+      # @param max [Integer] Upper limit for the generated integers (included).
+      # @return [Arbitrary<Integer>]
+      def nat(max: nil)
+        integer(min: 0, max: max)
+      end
+
+      # For arrays of values generated by `arb`.
+      #
+      # @param arb [Arbitrary<T>] Arbitrary used to generate the values of the array.
+      # @param min [Integer] Lower limit of the generated array size.
+      # @param max [Integer] Upper limit of the generated array size.
+      # @param empty [Boolean] Whether the array can be empty or not.
+      # @return [Arbitrary<T>]
+      def array(arb, min: 0, max: 10, empty: true)
+        raise ArgumentError if min < 0
+        min = 1 if min.zero? && !empty
+
+        ArrayArbitrary.new(arb, min, max)
+      end
+
+      # For tuples of values generated by `arbs`.
+      #
+      # @param arbs [Array<Arbitrary<...T>>] Arbitraries used to generate the values of the tuple.
+      # @return [Arbitrary<Array<...T>>]
+      def tuple(*arbs)
+        TupleArbitrary.new(*arbs)
+      end
+
+      # For fixed hashes of values generated by `hash`.
+      #
+      # @example
+      #   arb = Pbt.fixed_hash(x: Pbt.integer, y: Pbt.integer)
+      #   arb.generate(Random.new) # => {x: -450108, y: 42}
+      #
+      # @param hash [Hash<Object, Arbitrary<T>>] Hash with any keys and arbitraries as values.
+      # @return [Arbitrary<Hash<Object, T>>]
+      def fixed_hash(hash)
+        FixedHashArbitrary.new(hash)
+      end
+
+      # Picks a random integer in the given range.
+      #
+      # @see Pbt.one_of
+      # @param range [Range<Integer>] Range of integers to choose from.
+      # @return [Arbitrary<Integer>]
+      def choose(range)
+        ChooseArbitrary.new(range)
+      end
+
+      # Picks a random element from the given choices.
+      # The choices can be of any type.
+      #
+      # @see Pbt.one_of
+      # @param choices [Array<Object>] Array of choices.
+      # @return [Arbitrary<Object>]
+      def one_of(*choices)
+        OneOfArbitrary.new(choices)
+      end
+
+      # For a lowercase hexadecimal character.
+      #
+      # @return [Arbitrary<String>]
+      def hexa
+        one_of(*HEXA_CHARS)
+      end
+
+      # For lowercase hexadecimal stings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
+      def hexa_string(**kwargs)
+        array(hexa, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
+      end
+
+      # For a single unicode character (including printable and non-printable).
+      #
+      # @return [Arbitrary<String>]
+      def char
+        choose(CHAR_RANGE).map(CHAR_MAPPER, CHAR_UNMAPPER)
+      end
+
+      # For an alphanumeric character.
+      #
+      # @return [Arbitrary<String>]
+      def alphanumeric_char
+        one_of(*ALPHANUMERIC_CHARS)
+      end
+
+      # For alphanumeric strings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
+      def alphanumeric_string(**kwargs)
+        array(alphanumeric_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
+      end
+
+      # For an ascii character.
+      #
+      # @return [Arbitrary<String>]
+      def ascii_char
+        one_of(*ASCII_CHARS)
+      end
+
+      # For ascii strings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
+      def ascii_string(**kwargs)
+        array(ascii_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
+      end
+
+      # For a printable ascii character.
+      #
+      # @return [Arbitrary<String>]
+      def printable_ascii_char
+        one_of(*PRINTABLE_ASCII_CHARS)
+      end
+
+      # For printable ascii strings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
+      def printable_ascii_string(**kwargs)
+        array(printable_ascii_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
+      end
+
+      # For a printable character.
+      #
+      # @return [Arbitrary<String>]
+      def printable_char
+        one_of(*PRINTABLE_CHARS)
+      end
+
+      # For printable strings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
+      def printable_string(**kwargs)
+        array(printable_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
+      end
+
+      # For symbols.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<Symbol>]
+      def symbol(**kwargs)
+        array(one_of(*SYMBOL_SAFE_CHARS), empty: false, **kwargs).map(SYMBOL_MAPPER, SYMBOL_UNMAPPER)
+      end
+
+      # For floats.
+      #
+      # @return [Arbitrary<Float>]
+      def float
+        tuple(integer, integer).map(FLOAT_MAPPER, FLOAT_UNMAPPER)
+      end
+
+      # For symbols.
+      #
+      # @param arb [Arbitrary<T>] Arbitrary used to generate the values of the array.
+      # @param min [Integer] Lower limit of the generated set size.
+      # @param max [Integer] Upper limit of the generated set size.
+      # @param empty [Boolean] Whether the array can be empty or not.
+      # @return [Arbitrary<T>]
+      def set(arb, min: 0, max: 10, empty: true)
+        array(arb, min: min, max: max, empty: empty).map(SET_MAPPER, SET_UNMAPPER)
+      end
+
+      # For hashes of any keys and values.
+      # If you want to call `Object#hash` for `Pbt`, call this method without arguments.
+      #
+      # @example
+      #   hash_generator = Pbt.hash(Pbt.symbol, Pbt.integer)
+      #   hash_generator.generate(Random.new) # => {:buo=>466214, :cwftzvglq=>331431, :wweccnzg=>-848867}
+      #
+      # @see Pbt.array
+      # @param args [Array<Arbitrary<T,U>>] Arbitraries to generate Hash. First one is for key and second is for value.
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<Hash<T,U>>]
+      def hash(*args, **kwargs)
+        if args.size == 2
+          key_arbitrary, value_arbitrary = args
+          array(tuple(key_arbitrary, value_arbitrary), **kwargs).map(HASH_MAPPER, HASH_UNMAPPER)
+        else
+          super # call `Object#hash`
+        end
+      end
+
+      # For booleans.
+      #
+      # @return [Arbitrary<Boolean>]
+      def boolean
+        one_of(true, false)
+      end
+
+      # For any constant values.
+      # It's useful when you want to use a constant value that behaves like an arbitrary.
+      #
+      # @example
+      #   Pbt.constant(42).generate(Random.new) # => 42
+      #
+      # @param val [Object]
+      # @return [Arbitrary<Object>]
+      def constant(val)
+        ConstantArbitrary.new(val)
+      end
+
+      # For nil.
+      #
+      # @return [Arbitrary<nil>]
+      def nil
+        constant(nil)
+      end
+
+      # For dates between `base_date + past_offset_days` and `base_date + future_offset_days`.
+      #
+      # @param base_date [Date] Base date for the generated dates.
+      # @param past_offset_days [Integer] Offset days for the past. Default is -18250 (about 50 years).
+      # @param future_offset_days [Integer] Offset days for the future. Default is 18250 (about 50 years).
+      # @return [Arbitrary<Date>]
+      def date(base_date: Date.today, past_offset_days: -18250, future_offset_days: 18250)
+        offset_arb = integer(min: past_offset_days, max: future_offset_days)
+        offset_arb.map(DATE_MAPPER.call(base_date), DATE_UNMAPPER.call(base_date))
+      end
+
+      # For past dates between `base_date - past_offset_days` and `base_date`.
+      #
+      # @param base_date [Date] Base date for the generated dates.
+      # @param past_offset_days [Integer] Offset days for the past. Default is -18250 (about 50 years).
+      # @return [Arbitrary<Date>]
+      def past_date(base_date: Date.today, past_offset_days: -18250)
+        date(base_date: base_date, past_offset_days: past_offset_days, future_offset_days: 0)
+      end
+
+      # For future dates between `base_date` and `base_date - future_offset_days`.
+      #
+      # @param base_date [Date] Base date for the generated dates.
+      # @param future_offset_days [Integer] Offset days for the future. Default is 18250 (about 50 years).
+      # @return [Arbitrary<Date>]
+      def future_date(base_date: Date.today, future_offset_days: 18250)
+        date(base_date: base_date, past_offset_days: 0, future_offset_days: future_offset_days)
+      end
+
+      # For times between `base_time + past_offset_seconds` and `base_time + future_offset_seconds`.
+      #
+      # @param base_time [Date] Base time for the generated times.
+      # @param past_offset_seconds [Integer] Offset seconds for the past. Default is -1576800000 (about 50 years).
+      # @param future_offset_seconds [Integer] Offset seconds for the future. Default is 1576800000 (about 50 years).
+      # @return [Arbitrary<Time>]
+      def time(base_time: Time.now, past_offset_seconds: -1576800000, future_offset_seconds: 1576800000)
+        offset_arb = integer(min: past_offset_seconds, max: future_offset_seconds)
+        offset_arb.map(TIME_MAPPER.call(base_time), TIME_UNMAPPER.call(base_time))
+      end
+
+      # For past times between `base_time + past_offset_seconds` and `base_time`
+      #
+      # @param base_time [Date] Base time for the generated times.
+      # @param past_offset_seconds [Integer] Offset seconds for the past. Default is -1576800000 (about 50 years).
+      # @return [Arbitrary<Time>]
+      def past_time(base_time: Time.now, past_offset_seconds: -1576800000)
+        time(base_time: base_time, past_offset_seconds: past_offset_seconds, future_offset_seconds: 0)
+      end
+
+      # For future times between `base_time` and `base_time + future_offset_seconds`.
+      #
+      # @param base_time [Date] Base time for the generated times.
+      # @param future_offset_seconds [Integer] Offset seconds for the future. Default is 1576800000 (about 50 years).
+      # @return [Arbitrary<Time>]
+      def future_time(base_time: Time.now, future_offset_seconds: 1576800000)
+        time(base_time: base_time, past_offset_seconds: 0, future_offset_seconds: future_offset_seconds)
+      end
+    end
+  end
+end

data/lib/pbt/arbitrary/array_arbitrary.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates arrays of values generated by `value_arb` with type `T`.
+    class ArrayArbitrary < Arbitrary
+      DEFAULT_MAX_SIZE = 10
+      private_constant :DEFAULT_MAX_SIZE
+
+      # @param value_arb [Arbitrary] Arbitrary to generate values.
+      # @param min_length [Integer] Minimum length of the generated array. Default is 0.
+      # @param max_length [Integer] Maximum length of the generated array. Default is 10.
+      def initialize(value_arb, min_length = 0, max_length = DEFAULT_MAX_SIZE)
+        raise ArgumentError, "min_length must be zero or positive number" if min_length < 0
+
+        @min_length = min_length
+        @max_length = max_length
+        @value_arb = value_arb
+        @length_arb = IntegerArbitrary.new(min_length, max_length)
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        length = @length_arb.generate(rng)
+        length.times.map { @value_arb.generate(rng) }
+      end
+
+      # @see Arbitrary#shrink
+      def shrink(current)
+        return Enumerator.new { |_| } if current.size == @min_length
+
+        Enumerator.new do |y|
+          # First, shrink the length of the array and try combinations of elements.
+          # But this doesn't try all possible combinations since it'd be too huge and slow.
+          @length_arb.shrink(current.size).each do |length|
+            if length == 0
+              y.yield []
+              next
+            end
+            current.each_cons(length) do |con|
+              y.yield con
+            end
+          end
+
+          # Second, shrink each element of the array.
+          current.each_with_index do |item, i|
+            @value_arb.shrink(item).each do |val|
+              y.yield [*current[...i], val, *current[i + 1..]]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pbt/arbitrary/choose_arbitrary.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates a random value from a range.
+    class ChooseArbitrary < Arbitrary
+      # @param range [Range<Integer>]
+      def initialize(range)
+        @range = range
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        rng.rand(@range)
+      end
+
+      # @see Arbitrary#shrink
+      def shrink(current)
+        # Range is ordered from min to max, so we can just shrink towards min.
+        min, max = [@range.begin, @range.end].sort
+        IntegerArbitrary.new(min, max).shrink(current, target: min)
+      end
+    end
+  end
+end

data/lib/pbt/arbitrary/constant.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "date"
+require "set" # For 3.1 or prior. Set became built-in library since Ruby 3.2.0
+
+module Pbt
+  module Arbitrary
+    HEXA_CHARS = [*("0".."9"), *("a".."f")].freeze
+    CHAR_RANGE = (0..0x10FFFF)
+    SYMBOL_SAFE_CHARS = [*("a".."z"), "-"].freeze
+    ALPHANUMERIC_CHARS = [*("a".."z"), *("A".."Z"), *("0".."9")].freeze
+    PRINTABLE_ASCII_CHARS = [*(" ".."~")].freeze
+    ASCII_CHARS = [*PRINTABLE_ASCII_CHARS, "\n", "\r", "\t", "\v", "\b", "\f", "\e", "\d", "\a"].freeze
+    PRINTABLE_CHARS = [
+      *ASCII_CHARS,
+      *("\u{A0}".."\u{D7FF}"),
+      *("\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 }
+    SYMBOL_MAPPER = ->(v) { v.join.to_sym }
+    SYMBOL_UNMAPPER = ->(v) { v.to_s.chars }
+    FLOAT_MAPPER = ->((x, y)) { x.to_f / (y.to_f.abs + 1.0) }
+    FLOAT_UNMAPPER = ->(v) { [v, 0] }
+    SET_MAPPER = ->(v) { v.to_set }
+    SET_UNMAPPER = ->(v) { v.to_a }
+    HASH_MAPPER = ->(v) { v.to_h }
+    HASH_UNMAPPER = ->(v) { v.to_a }
+    DATE_MAPPER = ->(epoch) { ->(v) { epoch + v } }
+    DATE_UNMAPPER = ->(epoch) { ->(v) { (v - epoch).to_i } }
+    TIME_MAPPER = DATE_MAPPER
+    TIME_UNMAPPER = DATE_UNMAPPER
+  end
+end

data/lib/pbt/arbitrary/constant_arbitrary.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates a constant value.
+    class ConstantArbitrary < Arbitrary
+      # @param val [Object]
+      def initialize(val)
+        @val = val
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        @val
+      end
+
+      # @see Arbitrary#shrink
+      def shrink(current)
+        Enumerator.new {}
+      end
+    end
+  end
+end

data/lib/pbt/arbitrary/filter_arbitrary.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates values from another arbitrary, but only if they pass a predicate.
+    class FilterArbitrary < Arbitrary
+      # @param arb [Arbitrary] Arbitrary to generate values to be filtered.
+      # @param refinement [Proc] Predicate proc to test each produced element. Return true to keep the element, false otherwise.
+      def initialize(arb, &refinement)
+        @arb = arb
+        @refinement = refinement
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        loop do
+          val = @arb.generate(rng)
+          return val if @refinement.call(val)
+        end
+      end
+
+      # @see Arbitrary#shrink
+      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

data/lib/pbt/arbitrary/fixed_hash_arbitrary.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates a hash with fixed keys and arbitrary values.
+    class FixedHashArbitrary < Arbitrary
+      # @param hash [Hash<Object, Arbitrary<T>>] Hash with any keys and arbitraries as values.
+      def initialize(hash)
+        @keys = hash.keys
+        @arb = TupleArbitrary.new(*hash.values)
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        values = @arb.generate(rng)
+        @keys.zip(values).to_h
+      end
+
+      # @see Arbitrary#shrink
+      def shrink(current)
+        # This is not the most comprehensive but allows a reasonable number of entries in the shrink
+        Enumerator.new do |y|
+          @arb.shrink(current.values).each do |next_values|
+            y << @keys.zip(next_values).to_h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pbt/arbitrary/integer_arbitrary.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates random integers between `min` and `max`.
+    class IntegerArbitrary < Arbitrary
+      DEFAULT_TARGET = 0
+      private_constant :DEFAULT_TARGET
+
+      # @param min [Integer] Minimum value to generate.
+      # @param max [Integer] Maximum value to generate.
+      def initialize(min, max)
+        @min = min
+        @max = max
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        rng.rand(@min..@max)
+      end
+
+      # @see Arbitrary#shrink
+      def shrink(current, target: DEFAULT_TARGET)
+        gap = current - target
+        return Enumerator.new { |_| } if gap == 0
+
+        is_positive_gap = gap > 0
+
+        Enumerator.new do |y|
+          while (diff = (current - target).abs) > 1
+            halved = diff / 2
+            current -= is_positive_gap ? halved : -halved
+            y.yield current
+          end
+          y.yield target # no diff here
+        end
+      end
+    end
+  end
+end

data/lib/pbt/arbitrary/map_arbitrary.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates a mapped value from another arbitrary.
+    class MapArbitrary < Arbitrary
+      # @param arb [Arbitrary] Arbitrary to generate values to be mapped.
+      # @param mapper [Proc] Proc to map generated values. Mainly used for generation.
+      # @param unmapper [Proc] Proc to unmap generated values. Used for shrinking.
+      def initialize(arb, mapper, unmapper)
+        @arb = arb
+        @mapper = mapper
+        @unmapper = unmapper
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        @mapper.call(@arb.generate(rng))
+      end
+
+      # @see Arbitrary#shrink
+      def shrink(current)
+        Enumerator.new do |y|
+          @arb.shrink(@unmapper.call(current)).each do |v|
+            y.yield @mapper.call(v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pbt/arbitrary/one_of_arbitrary.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates one of the given choices.
+    class OneOfArbitrary < Arbitrary
+      # @param choices [Array] List of choices.
+      def initialize(choices)
+        @choices = choices
+        @idx_arb = IntegerArbitrary.new(0, choices.size - 1)
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        @choices[@idx_arb.generate(rng)]
+      end
+
+      # @see Arbitrary#shrink
+      def shrink(current)
+        # Shrinks to values earlier in the list of `choices`.
+        Enumerator.new do |y|
+          @idx_arb.shrink(@choices.index(current)).map do |idx|
+            y << @choices[idx]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pbt/arbitrary/tuple_arbitrary.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Arbitrary
+    # Generates a tuple of arbitrary values.
+    class TupleArbitrary < Arbitrary
+      # @param arbs [Array<Arbitrary>] Arbitraries used to generate the values of the tuple.
+      def initialize(*arbs)
+        @arbs = arbs
+      end
+
+      # @see Arbitrary#generate
+      def generate(rng)
+        @arbs.map { |arb| arb.generate(rng) }
+      end
+
+      # @see Arbitrary#shrink
+      def shrink(current)
+        # This is not the most comprehensive but allows a reasonable number of entries in the shrink.
+        Enumerator.new do |y|
+          @arbs.each_with_index do |arb, idx|
+            arb.shrink(current[idx]).each do |v|
+              next_values = current.dup
+              next_values[idx] = v
+              y << next_values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pbt/check/case.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pbt
+  module Check
+    # @private
+    Case = Struct.new(:val, :ractor, :exception, :index, keyword_init: true)
+  end
+end