pbt 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f0aceef7e66e5512062e15dc72d8bf97617bf99f8c800b320381ef4e48562ab
-  data.tar.gz: ff29061f4878170a57e1ce919cee6f065548349c876343c376e22047ef63c5c4
+  metadata.gz: 3275eafb6d07373c24f422feafa7300962213568a387cd21fbcd648c85de4193
+  data.tar.gz: 7a3b902bb323251050ec023ec8318244d777c0bc2584ad0c8bad2504d93888f0
 SHA512:
-  metadata.gz: 68e5b018aaceebd522d8ef3f7e3837bc469b0a4513fd0e8e4080a01b637ca219694d9605c38752f60eb5cde1ee414c5116c0e153a8077ac1d9f8d28aa8ab3ef5
-  data.tar.gz: 26e75baa90dfe41b0a8b0bcd625e8b39c69480e0a2343daca161ce0100fd6c72386c62d9c0a2afb5072c4baec39b4ccc41b499e650080093fad187791e883c60
+  metadata.gz: e72d6278580f540b7d0aad1aefb168c2fbc7a3e64d31a90a4929695b979d3d1c29e3dc06fb22fb0fc6d1aadfc121605176cbee7146e298201f9091c0fa2ea647
+  data.tar.gz: 8967245b883d22dfb00d79b0433acc53502e3e9ecdb07e89bae04002ce413fd67d126f695f4a4e12a965fc7adf171b5cd8e1c9fd3e6d8d28e8ff4444113cbea5

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.7.0] - 2026-04-04
+
+- [Breaking change] Simplify stateful command protocol: `arguments` must now accept `state` parameter, and `applicable?` must now accept both `state` and `args` parameters
+- Make `rng` optional in all arbitrary `generate` methods with default `Random.new` [#44](https://github.com/ohbarye/pbt/pull/44)
+- Mark stateful testing API as stable (no longer experimental)
+
 ## [0.6.0] - 2026-03-15
 
 - Add experimental `Pbt.stateful` API for model-based stateful property testing [#38](https://github.com/ohbarye/pbt/pull/38)

data/README.md

@@ -34,7 +34,7 @@ Add this line to your application's Gemfile and run `bundle install`.
 gem 'pbt'
 ```
 
-Off course you can install with `gem intstall pbt`.
+Of course you can install with `gem install pbt`.
 
 ## Basic Usage
 
@@ -108,34 +108,37 @@ There are many built-in arbitraries in `Pbt`. You can use them to generate rando
 #### Primitives
 
 ```ruby
-rng = Random.new
+Pbt.integer.generate                  # => 42
+Pbt.integer(min: -1, max: 8).generate # => Integer between -1 and 8
 
-Pbt.integer.generate(rng)                  # => 42
-Pbt.integer(min: -1, max: 8).generate(rng) # => Integer between -1 and 8
+Pbt.symbol.generate                   # => :atq
 
-Pbt.symbol.generate(rng)                   # => :atq
+Pbt.ascii_char.generate               # => "a"
+Pbt.ascii_string.generate             # => "aagjZfao"
 
-Pbt.ascii_char.generate(rng)               # => "a"
-Pbt.ascii_string.generate(rng)             # => "aagjZfao"
+Pbt.boolean.generate                  # => true or false
+Pbt.constant(42).generate             # => 42 always
+```
+
+You can also pass a custom random number generator if needed:
 
-Pbt.boolean.generate(rng)                  # => true or false
-Pbt.constant(42).generate(rng)             # => 42 always
+```ruby
+rng = Random.new(42) # with a specific seed for reproducibility
+Pbt.integer.generate(rng)
 ```
 
 #### Composites
 
 ```ruby
-rng = Random.new
-
-Pbt.array(Pbt.integer).generate(rng)                        # => [121, -13141, 9825]
-Pbt.array(Pbt.integer, max: 1, empty: true).generate(rng)   # => [] or [42] etc.
+Pbt.array(Pbt.integer).generate                        # => [121, -13141, 9825]
+Pbt.array(Pbt.integer, max: 1, empty: true).generate   # => [] or [42] etc.
 
-Pbt.tuple(Pbt.symbol, Pbt.integer).generate(rng)            # => [:atq, 42]
+Pbt.tuple(Pbt.symbol, Pbt.integer).generate            # => [:atq, 42]
 
-Pbt.fixed_hash(x: Pbt.symbol, y: Pbt.integer).generate(rng) # => {x: :atq, y: 42}
-Pbt.hash(Pbt.symbol, Pbt.integer).generate(rng)             # => {atq: 121, ygab: -1142}
+Pbt.fixed_hash(x: Pbt.symbol, y: Pbt.integer).generate # => {x: :atq, y: 42}
+Pbt.hash(Pbt.symbol, Pbt.integer).generate             # => {atq: 121, ygab: -1142}
 
-Pbt.one_of(:a, 1, 0.1).generate(rng)                        # => :a or 1 or 0.1
+Pbt.one_of(:a, 1, 0.1).generate                        # => :a or 1 or 0.1
 ````
 
 See [ArbitraryMethods](https://github.com/ohbarye/pbt/blob/main/lib/pbt/arbitrary/arbitrary_methods.rb) module for more details.
@@ -169,11 +172,11 @@ class IncrementCommand
     :increment
   end
 
-  def arguments
+  def arguments(_state)
     Pbt.nil
   end
 
-  def applicable?(_state)
+  def applicable?(_state, _args)
     true
   end
 
@@ -220,8 +223,8 @@ end
 - `model.initial_state`
 - `model.commands(state)` -> `Array<command>`
 - `command.name`
-- `command.arguments` (a `Pbt` arbitrary)
-- `command.applicable?(state)` -> `true` / `false`
+- `command.arguments(state)` (a `Pbt` arbitrary, may depend on current model state)
+- `command.applicable?(state, args)` -> `true` / `false`
 - `command.next_state(state, args)` -> next model state
 - `command.run!(sut, args)` -> command result
 - `command.verify!(before_state:, after_state:, args:, result:, sut:)`
@@ -421,7 +424,7 @@ Once this project finishes the following, we will release v1.0.0.
 - [ ] Statistics feature to aggregate generated values
 - [ ] Decide DSL
 - [ ] Try Fiber
-- [ ] Stateful property-based testing
+- [x] Stateful property-based testing (experimental, via `Pbt.stateful`)
 
 ## Development
 

data/lib/pbt/arbitrary/arbitrary.rb

@@ -11,9 +11,9 @@ module Pbt
       # Generate a value of type `T`, based on the provided random number generator.
       #
       # @abstract
-      # @param rng [Random] Random number generator.
+      # @param rng [Random] Random number generator. Defaults to a new Random instance.
       # @return [Object] Random value of type `T`.
-      def generate(rng)
+      def generate(rng = Random.new)
         raise NotImplementedError
       end
 

data/lib/pbt/arbitrary/array_arbitrary.rb

@@ -20,7 +20,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         length = @length_arb.generate(rng)
         length.times.map { @value_arb.generate(rng) }
       end

data/lib/pbt/arbitrary/choose_arbitrary.rb

@@ -10,7 +10,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         rng.rand(@range)
       end
 

data/lib/pbt/arbitrary/constant_arbitrary.rb

@@ -10,7 +10,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         @val
       end
 

data/lib/pbt/arbitrary/filter_arbitrary.rb

@@ -12,7 +12,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         loop do
           val = @arb.generate(rng)
           return val if @refinement.call(val)

data/lib/pbt/arbitrary/fixed_hash_arbitrary.rb

@@ -11,7 +11,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         values = @arb.generate(rng)
         @keys.zip(values).to_h
       end

data/lib/pbt/arbitrary/integer_arbitrary.rb

@@ -15,7 +15,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         rng.rand(@min..@max)
       rescue ArgumentError => e
         raise EmptyDomainError, e.message if @min > @max

data/lib/pbt/arbitrary/map_arbitrary.rb

@@ -14,7 +14,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         @mapper.call(@arb.generate(rng))
       end
 

data/lib/pbt/arbitrary/one_of_arbitrary.rb

@@ -11,7 +11,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         @choices[@idx_arb.generate(rng)]
       end
 

data/lib/pbt/arbitrary/tuple_arbitrary.rb

@@ -10,7 +10,7 @@ module Pbt
       end
 
       # @see Arbitrary#generate
-      def generate(rng)
+      def generate(rng = Random.new)
         @arbs.map { |arb| arb.generate(rng) }
       end
 

data/lib/pbt/check/property.rb

@@ -16,7 +16,7 @@ module Pbt
       #
       # @param rng [Random] Random number generator.
       # @return [Object]
-      def generate(rng)
+      def generate(rng = Random.new)
         @arb.generate(rng)
       end
 

data/lib/pbt/stateful/property.rb

@@ -50,7 +50,7 @@ module Pbt
       #
       # @param rng [Random]
       # @return [Array<Step>]
-      def generate(rng)
+      def generate(rng = Random.new)
         length = rng.rand(0..@max_steps)
         state = @model.initial_state
         sequence = []
@@ -207,11 +207,6 @@ module Pbt
             "Pbt.stateful command protocol mismatch for #{command.class} " \
             "(name=#{safe_command_label(command)}, missing: #{missing_methods.join(", ")}, context=#{context})"
         end
-
-        validate_command_signature!(command, :arguments, valid_counts: [0, 1], expectation: "arguments or arguments(state)",
-          context:)
-        validate_command_signature!(command, :applicable?, valid_counts: [1, 2],
-          expectation: "applicable?(state) or applicable?(state, args)", context:)
       end
 
       # @param command [Object]
@@ -252,12 +247,6 @@ module Pbt
       # @param context [String]
       # @return [Object]
       def generate_applicable_args(command, state, rng, context:)
-        unless arg_aware_command?(command)
-          return NoApplicableArgs unless applicable?(command, state, nil, context:)
-
-          return arbitrary_for(command, state, context:).generate(rng)
-        end
-
         arbitrary = arbitrary_for(command, state, context:)
 
         ARG_AWARE_GENERATION_ATTEMPTS.times do
@@ -275,15 +264,7 @@ module Pbt
       # @param context [String]
       # @return [Object]
       def arguments_for(command, state, context:)
-        method = command.method(:arguments)
-
-        if supports_argument_count?(method, 1)
-          command.arguments(state)
-        elsif supports_argument_count?(method, 0)
-          command.arguments
-        else
-          raise_invalid_signature!(command, :arguments, "arguments or arguments(state)", context)
-        end
+        command.arguments(state)
       end
 
       # @param command [Object]
@@ -303,8 +284,6 @@ module Pbt
       def generate_args_for(command, arbitrary, rng)
         arbitrary.generate(rng)
       rescue Pbt::Arbitrary::EmptyDomainError
-        raise unless state_aware_arg_aware_command?(command)
-
         NoApplicableArgs
       end
 
@@ -314,84 +293,7 @@ module Pbt
       # @param context [String]
       # @return [Boolean]
       def applicable?(command, state, args, context:)
-        method = command.method(:applicable?)
-
-        if supports_argument_count?(method, 2)
-          command.applicable?(state, args)
-        elsif supports_argument_count?(method, 1)
-          command.applicable?(state)
-        else
-          raise_invalid_signature!(command, :applicable?, "applicable?(state) or applicable?(state, args)", context)
-        end
-      end
-
-      # @param command [Object]
-      # @return [Boolean]
-      def arg_aware_command?(command)
-        supports_argument_count?(command.method(:applicable?), 2)
-      end
-
-      # @param command [Object]
-      # @return [Boolean]
-      def state_aware_arg_aware_command?(command)
-        arg_aware_command?(command) && supports_argument_count?(command.method(:arguments), 1)
-      end
-
-      # @param command [Object]
-      # @param method_name [Symbol]
-      # @param valid_counts [Array<Integer>]
-      # @param expectation [String]
-      # @param context [String]
-      # @return [void]
-      def validate_command_signature!(command, method_name, valid_counts:, expectation:, context:)
-        method = command.method(method_name)
-        return if valid_counts.any? { |count| supports_argument_count?(method, count) }
-
-        raise_invalid_signature!(command, method_name, expectation, context)
-      end
-
-      # @param command [Object]
-      # @param method_name [Symbol]
-      # @param expectation [String]
-      # @param context [String]
-      # @return [void]
-      def raise_invalid_signature!(command, method_name, expectation, context)
-        raise Pbt::InvalidConfiguration,
-          "Pbt.stateful command protocol mismatch for #{command.class} " \
-          "(name=#{safe_command_label(command)}, invalid #{method_name} signature; expected #{expectation}, context=#{context})"
-      end
-
-      # @param method [Method]
-      # @param count [Integer]
-      # @return [Boolean]
-      def supports_argument_count?(method, count)
-        return false if method.parameters.any? { |kind, _name| keyword_parameter?(kind) }
-
-        required = 0
-        optional = 0
-        rest = false
-
-        method.parameters.each do |kind, _name|
-          case kind
-          when :req
-            required += 1
-          when :opt
-            optional += 1
-          when :rest
-            rest = true
-          end
-        end
-
-        return false if count < required
-        return true if rest
-
-        count <= required + optional
-      end
-
-      # @param kind [Symbol]
-      # @return [Boolean]
-      def keyword_parameter?(kind)
-        %i[keyreq key keyrest].include?(kind)
+        command.applicable?(state, args)
       end
 
       # @param sequence [Array<Hash, Step>]

data/lib/pbt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pbt
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pbt
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - ohbarye