games_dice 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c1046747fdad80e794bb7883aaaade1a14e737a39641b6e85e7c179e96a3375
-  data.tar.gz: 54b1c1aa41b58b53e8a72ad59f835de932fde926a038626a0df165605677300c
+  metadata.gz: 8e1494acd8aaa52a4d11f10bc8507c872be7eff6e77e6ad3d628d58d900a7e45
+  data.tar.gz: fb92f1c294ec39199c7a98f52ffae82620f25dce69ee92afe08e630bcc273692
 SHA512:
-  metadata.gz: 60e56aa2b32a4550ae6334c372ad1a9b0a07820c8a58ae4ce07c0ae3d5721ff91b8422d3d2d52b690e387738d3ee5bb6a7c05bed2d40145b776ef9a9d6295c0c
-  data.tar.gz: 7a0e7c3759def3b6f482e4242ae23b770c50876fc26f5464bca4e77b91cbf64596c901c4eb9cc69e9eee351d63fa8978426ceae7125eb34aa7c3e0856a0a8e1e
+  metadata.gz: 3cf986407235b5bf5017695d61d2ae6dcde5287233d94f07b1c716763913bfb88c7e99c21bab98a684c1939e17cc2a827d5225b35808a241bf3c83c71730d351
+  data.tar.gz: 5b5ec53e5140dfa03fd56b5e5c4115a25547f591305c9993ed1a1ebfb747d84e3441c0cd4a9eda394e1b76998230274441d3e9b20c39d115722008ede3637928

data/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  push:
+
+permissions:
+  contents: read
+
+jobs:
+  rspec:
+    name: RSpec (Ruby ${{ matrix.ruby }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.3', '3.4']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rake compile spec
+
+  rubocop:
+    name: RuboCop (Ruby ${{ matrix.ruby }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.3', '3.4']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rubocop

data/.gitignore

@@ -16,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.DS_Store

data/.rubocop.yml

@@ -1,15 +1,53 @@
+plugins:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
 AllCops:
-  TargetRubyVersion: 2.6.0
+  TargetRubyVersion: 3.3
   NewCops: enable
+  SuggestExtensions: false
 
 Layout/LineLength:
   Max: 120
   
 Metrics/BlockLength:
-  IgnoredMethods:
+  AllowedMethods:
     - context
     - describe
     - shared_examples
     - define
-  
 
+RSpec/ExampleLength:
+  Max: 25
+
+RSpec/MultipleExpectations:
+  Max: 21
+
+RSpec/NestedGroups:
+  Max: 4
+
+# This project keeps specs flat so they are easy to run individually.
+RSpec/SpecFilePathFormat:
+  Enabled: false
+
+RSpec/IndexedLet:
+  Enabled: false
+
+RSpec/InstanceVariable:
+  Exclude:
+    - spec/complex_die_spec.rb
+
+RSpec/MultipleDescribes:
+  Exclude:
+    - spec/readme_spec.rb
+
+RSpec/DescribeClass:
+  Exclude:
+    - spec/readme_spec.rb
+
+# Probabilities implements #each without mixing in Enumerable; these specs
+# intentionally collect yielded pairs manually.
+Style/MapIntoArray:
+  Exclude:
+    - spec/probability_spec.rb

data/.yardopts

@@ -1,5 +1,5 @@
 lib/**/*.rb
---exclude ext
+ext/**/*.c
 --no-private
 -
 README.md

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # GamesDice Changelog
 
+## 0.4.2 ( 19 July 2026 )
+
+ * Require MRI Ruby 3.3 or later and test against Ruby 3.3 and 3.4.
+ * Update development and runtime dependencies.
+ * Replace Travis CI with GitHub Actions.
+ * Modernise the RSpec suite and RuboCop configuration.
+ * Correct and clarify README documentation.
+
+## 0.4.1
+
+ * Tidy up documentation and address some Rubocop offences.
+
 ## 0.4.0 ( 19 September 2021 )
 
  * Dropping support for older Ruby versions (< 2.6)

data/Gemfile

@@ -4,3 +4,13 @@ source 'https://rubygems.org'
 
 # Dependencies are in games_dice.gemspec
 gemspec
+
+gem 'rake', '~> 13.2'
+gem 'rake-compiler', '~> 1.2'
+gem 'redcarpet', '~> 3.6'
+gem 'rspec', '~> 3.13'
+gem 'rubocop', '~> 1.75', require: false
+gem 'rubocop-performance', '~> 1.25', require: false
+gem 'rubocop-rake', '~> 0.7', require: false
+gem 'rubocop-rspec', '~> 3.6', require: false
+gem 'yard', '~> 0.9'

data/README.md

@@ -1,10 +1,4 @@
 # GamesDice
-[![Gem Version](https://badge.fury.io/rb/games_dice.png)](http://badge.fury.io/rb/games_dice)
-[![Build Status](https://travis-ci.org/neilslater/games_dice.png?branch=master)](http://travis-ci.org/neilslater/games_dice)
-[![Coverage Status](https://coveralls.io/repos/neilslater/games_dice/badge.png?branch=master)](https://coveralls.io/r/neilslater/games_dice?branch=master)
-[![Inline docs](http://inch-ci.org/github/neilslater/games_dice.png?branch=master)](http://inch-ci.org/github/neilslater/games_dice)
-[![Code Climate](https://codeclimate.com/github/neilslater/games_dice.png)](https://codeclimate.com/github/neilslater/games_dice)
-[![Dependency Status](https://gemnasium.com/neilslater/games_dice.png)](https://gemnasium.com/neilslater/games_dice)
 
 A library for simulating dice. Use it to construct dice-rolling systems used in role-playing and board games.
 
@@ -30,11 +24,10 @@ gem as-is, and add them as features within your project code.
 
 ## Supported Ruby Versions
 
-GamesDice is tested routinely on MRI Rubies 1.9.3, 2.0.0, 2.1.0, 2.1.1 and JRuby, and the
-"build passing" badge is based on those tests.
+GamesDice 0.4.2 supports MRI Ruby 3.3 and 3.4. It uses a native extension and does not support JRuby.
 
-It *should* also work in versions from 1.8.7, in Ruby Enterprise and in Rubinius, but it
-is not tested routinely on those Rubies.
+GamesDice 0.4.0 and 0.4.1 support MRI Ruby 2.6 and later. Versions before 0.4.0 also provide a
+pure-Ruby implementation of the probability calculations and can be used with JRuby.
 
 ## Installation
 
@@ -50,21 +43,6 @@ Or install it yourself as:
 
     $ gem install games_dice
 
-When installed, GamesDice will attempt to install Ruby native extensions in C, for speeding up probabilities
-calculations. However, all the features are available in pure Ruby, and the gem should fall back to that
-automatically on installation if your system does not support C native extensions. You can verify which
-is being installed by installing the gem in verbose mode:
-
-    $ gem install games_dice --verbose
-
-You can also verify which version you are using in Ruby by calling the class method:
-
-    GamesDice::Probabilities.implemented_in
-
-which will return either *:ruby* or *:c*. Other than this method, and a speed difference between
-implementations, there should be no other difference. If you find one, then it will be considered
-as a bug.
-
 ## Usage
 
     require 'games_dice'
@@ -88,8 +66,8 @@ Converts a string such as '3d6+6' into a GamesDice::Dice object
 
 Parameters:
 
- * dice_description is a string such as '3d6' or '2d4-1'. See String Dice Descriptions below for possibilities.
- * prng is optional, if provided it should be an object that has a method 'rand( integer )' that works like Ruby's built-in rand method
+ * `dice_description` is a string such as `3d6` or `2d4-1`. See String Dice Descriptions below for possibilities.
+ * `prng` is optional. If provided, it must respond to `rand(integer)` in the same way as Ruby's built-in `rand` method.
 
 Returns a GamesDice::Dice object.
 
@@ -215,12 +193,12 @@ Returns the probability of a result less than or equal to the integer n.
 
 Returns the probability of a result less than the integer n.
 
-    probabilities.p_lt( 17 )  # => 0.9953703703703
+    probabilities.p_lt( 17 )  # => 0.9814814814814
     probabilities.p_lt( 3 )   # => 0.0
 
 #### probabilities.expected
 
-Returns the mean result, weighted by probabality of each value.
+Returns the mean result, weighted by the probability of each value.
 
     probabilities.expected  # => 10.5 (rounded to nearest 1e-9)
 
@@ -254,7 +232,7 @@ A die modifier can also be a single letter plus an integer value, e.g.
 
     1d6r1
 
-You can add comma-seperated parameters to a modifier by using a ":" (colon) character after the
+You can add comma-separated parameters to a modifier by using a ":" (colon) character after the
 modifier letter, and a "." (full stop) to signify the end of the parameters. What parameters are
 accepted, and what they mean, depends on the modifier:
 
@@ -272,7 +250,7 @@ are all equivalent.
 #### Rerolls
 
 You can specify that dice rolling certain values should be re-rolled, and how that re-roll should be
-interpretted.
+interpreted.
 
 The simple form specifies a low value that will automatically trigger a re-roll and replace:
 
@@ -287,7 +265,7 @@ The full version of this modifier, allows you to specify from 1 to 3 parameters:
 
 Where:
 
- * VALUE_COMPARISON is one of >, >=, == (default), <= < plus an integer to set conditions on when the reroll should occur
+ * VALUE_COMPARISON is one of `>`, `>=`, `==` (default), `<=`, or `<`, plus an integer that determines when the reroll occurs
  * REROLL_TYPE is one of
   * replace (default) - use the new value in place of existing value for the die
   * add - add result of reroll to running total, and ignore any subtract rules
@@ -319,7 +297,7 @@ The full version of this modifier, allows you to specify from 1 to 3 parameters:
 
 Where:
 
- * VALUE_COMPARISON is one of >, >= (default), ==, <= < plus an integer to set conditions on when the map should occur
+ * VALUE_COMPARISON is one of `>`, `>=` (default), `==`, `<=`, or `<`, plus an integer that determines when the map occurs
  * MAP_VALUE is an integer that will be used in place of a result from a die, default value is 1
   * maps are tested in order that they are declared, and first one that matches is applied
   * when at least one map has been defined, all unmapped values default to 0

data/Rakefile

@@ -5,14 +5,8 @@ require 'rspec/core/rake_task'
 require 'rake/extensiontask'
 require 'yard'
 
-def can_compile_extensions
-  return false if RUBY_DESCRIPTION =~ /jruby/
-
-  true
-end
-
 desc 'GamesDice unit tests'
-RSpec::Core::RakeTask.new(:test) do |t|
+RSpec::Core::RakeTask.new(:spec) do |t|
   t.pattern = 'spec/*_spec.rb'
   t.verbose = false
 end
@@ -30,14 +24,4 @@ Rake::ExtensionTask.new do |ext|
   ext.gem_spec = gemspec
 end
 
-task :delete_compiled_ext do |_t|
-  `rm lib/games_dice/games_dice.*`
-end
-
-task pure_test: %i[delete_compiled_ext test]
-
-if can_compile_extensions
-  task default: %i[compile test]
-else
-  task default: [:test]
-end
+task default: %i[compile spec]

data/ext/games_dice/games_dice.c

@@ -8,5 +8,5 @@ VALUE GamesDice = Qnil;
 
 void Init_games_dice() {
   GamesDice = rb_define_module("GamesDice");
-  init_probabilities_class( GamesDice );
+  init_probabilities_class();
 }

data/ext/games_dice/probabilities.c

@@ -574,6 +574,13 @@ int copy_key_value( VALUE key, VALUE val, VALUE obj ) {
 //  Ruby class and instance methods for Probabilities
 //
 
+/*
+ * @overload initialize(probs, offset)
+ *   Creates new instance of GamesDice::Probabilities.
+ *   @param [Array<Float>] probs Each entry in the array is the probability of getting a result
+ *   @param [Integer] offset The result associated with index of 0 in the array
+ *   @return [GamesDice::Probabilities]
+ */
 VALUE probabilities_initialize( VALUE self, VALUE arr, VALUE offset ) {
   int i, o, s;
   double error, p_item;
@@ -604,7 +611,11 @@ VALUE probabilities_initialize( VALUE self, VALUE arr, VALUE offset ) {
   return self;
 }
 
-
+/*
+ * @overload clone
+ *   Cloning an object of this class creates a deep copy of the probabilities hash.
+ *   @return [GamesDice::Probabilities]
+ */
 VALUE probabilities_initialize_copy( VALUE copy, VALUE orig ) {
   ProbabilityList *pl_copy;
   ProbabilityList *pl_orig;
@@ -622,6 +633,12 @@ VALUE probabilities_initialize_copy( VALUE copy, VALUE orig ) {
   return copy;
 }
 
+/*
+ * A hash representation of the distribution. Each key is an integer result,
+ * and the matching value is probability of getting that result. A new hash is generated on each
+ * call to this method.
+ * @return [Hash]
+ */
 VALUE probabilities_to_h( VALUE self ) {
   ProbabilityList *pl = get_probability_list( self );
   VALUE h = rb_hash_new();
@@ -637,56 +654,126 @@ VALUE probabilities_to_h( VALUE self ) {
   return h;
 }
 
+/*
+ * @overload min
+ *   @!attribute [r] min
+ *   Minimum result in the distribution
+ *   @return [Integer]
+ */
 VALUE probabilities_min( VALUE self ) {
   return INT2NUM( pl_min(  get_probability_list( self ) ) );
 }
 
+/*
+ * @overload max
+ *   @!attribute [r] max
+ *   Maximum result in the distribution
+ *   @return [Integer]
+ */
 VALUE probabilities_max( VALUE self ) {
   return INT2NUM( pl_max( get_probability_list( self ) ) );
 }
 
+/*
+ * Probability of result equalling specific target
+ * @param [Integer] target
+ * @return [Float] in range (0.0..1.0)
+ */
 VALUE probabilites_p_eql( VALUE self, VALUE target ) {
   return DBL2NUM( pl_p_eql( get_probability_list( self ), NUM2INT(target) ) );
 }
 
+/*
+ * Probability of result being greater than specific target
+ * @param [Integer] target
+ * @return [Float] in range (0.0..1.0)
+ */
 VALUE probabilites_p_gt( VALUE self, VALUE target ) {
   return DBL2NUM( pl_p_gt( get_probability_list( self ), NUM2INT(target) ) );
 }
 
+/*
+ * Probability of result being equal to or greater than specific target
+ * @param [Integer] target
+ * @return [Float] in range (0.0..1.0)
+ */
 VALUE probabilites_p_ge( VALUE self, VALUE target ) {
   return DBL2NUM( pl_p_ge( get_probability_list( self ), NUM2INT(target) ) );
 }
 
+/*
+ * Probability of result being equal to or less than specific target
+ * @param [Integer] target
+ * @return [Float] in range (0.0..1.0)
+ */
 VALUE probabilites_p_le( VALUE self, VALUE target ) {
   return DBL2NUM( pl_p_le( get_probability_list( self ), NUM2INT(target) ) );
 }
 
+/*
+ * Probability of result being less than specific target
+ * @param [Integer] target
+ * @return [Float] in range (0.0..1.0)
+ */
 VALUE probabilites_p_lt( VALUE self, VALUE target ) {
   return DBL2NUM( pl_p_lt( get_probability_list( self ), NUM2INT(target) ) );
 }
 
+/*
+ * @overload expected
+ *   @!attribute [r] expected
+ *   Expected value of distribution.
+ *   @return [Float]
+ */
 VALUE probabilites_expected( VALUE self ) {
   return DBL2NUM( pl_expected( get_probability_list( self ) ) );
 }
 
+/*
+ * Probability distribution derived from this one, where we know (or are only interested in
+ * situations where) the result is greater than or equal to target.
+ * @param [Integer] target
+ * @return [GamesDice::Probabilities] new distribution.
+ */
 VALUE probabilities_given_ge( VALUE self, VALUE target ) {
   int t = NUM2INT(target);
   ProbabilityList *pl = get_probability_list( self );
   return pl_as_ruby_class( pl_given_ge( pl, t ), Probabilities );
 }
 
+/*
+ * Probability distribution derived from this one, where we know (or are only interested in
+ * situations where) the result is less than or equal to target.
+ * @param [Integer] target
+ * @return [GamesDice::Probabilities] new distribution.
+ */
 VALUE probabilities_given_le( VALUE self, VALUE target ) {
   int t = NUM2INT(target);
   ProbabilityList *pl = get_probability_list( self );
   return pl_as_ruby_class( pl_given_le( pl, t ), Probabilities );
 }
 
+/*
+ * @overload repeat_sum(n)
+ *   Adds a distribution to itself repeatedly, to simulate a number of dice
+ *   results being summed.
+ *   @param [Integer] n Number of repetitions, must be at least 1
+ *   @return [GamesDice::Probabilities] new distribution
+ */
 VALUE probabilities_repeat_sum( VALUE self, VALUE nsum ) {
   int n = NUM2INT(nsum);
   ProbabilityList *pl = get_probability_list( self );
   return pl_as_ruby_class( pl_repeat_sum( pl, n ), Probabilities );
 }
 
+/* 
+ * @overload repeat_n_sum_k(n, k, kmode = :keep_best)
+ *   Calculates distribution generated by summing best k results of n iterations
+ *   of the distribution.
+ *   @param [Integer] n Number of repetitions, must be at least 1
+ *   @param [Integer] k Number of best results to keep and sum
+ *   @return [GamesDice::Probabilities] new distribution
+ */
 VALUE probabilities_repeat_n_sum_k( int argc, VALUE* argv, VALUE self ) {
   VALUE nsum, nkeepers, kmode;
   int keep_best, n, k;
@@ -709,6 +796,12 @@ VALUE probabilities_repeat_n_sum_k( int argc, VALUE* argv, VALUE self ) {
   return pl_as_ruby_class( pl_repeat_n_sum_k( pl, n, k, keep_best ), Probabilities );
 }
 
+/*  
+ * Iterates through value, probability pairs
+ * @yieldparam [Integer] result A result that may be possible in the dice scheme
+ * @yieldparam [Float] probability Probability of result, in range 0.0..1.0
+ * @return [GamesDice::Probabilities] this object
+ */
 VALUE probabilities_each( VALUE self ) {
   ProbabilityList *pl = get_probability_list( self );
   int i;
@@ -725,6 +818,11 @@ VALUE probabilities_each( VALUE self ) {
   return self;
 }
 
+/*
+ * Distribution for a die with equal chance of rolling 1..N
+ * @param [Integer] sides Number of sides on die
+ * @return [GamesDice::Probabilities]
+ */
 VALUE probabilities_for_fair_die( VALUE self, VALUE sides ) {
   int s = NUM2INT( sides );
   VALUE obj;
@@ -743,6 +841,13 @@ VALUE probabilities_for_fair_die( VALUE self, VALUE sides ) {
   return obj;
 }
 
+/* 
+ * @overload from_h(prob_hash)
+ *   Creates new instance of GamesDice::Probabilities.
+ *   @param [Hash] prob_hash A hash representation of the distribution, each key is an integer result,
+ *     and the matching value is probability of getting that result
+ *   @return [GamesDice::Probabilities]
+ */
 VALUE probabilities_from_h( VALUE self, VALUE hash ) {
   VALUE obj;
   ProbabilityList *pl;
@@ -773,6 +878,14 @@ VALUE probabilities_from_h( VALUE self, VALUE hash ) {
   return obj;
 }
 
+/*
+ * @overload add_distributions(pd_a, pd_b)
+ *   Combines two distributions to create a third, that represents the distribution created when adding
+ *   results together.
+ *   @param [GamesDice::Probabilities] pd_a First distribution
+ *   @param [GamesDice::Probabilities] pd_b Second distribution
+ *   @return [GamesDice::Probabilities]
+ */
 VALUE probabilities_add_distributions( VALUE self, VALUE gdpa, VALUE gdpb ) {
   ProbabilityList *pl_a = get_probability_list( gdpa );
   ProbabilityList *pl_b = get_probability_list( gdpb );
@@ -783,6 +896,16 @@ VALUE probabilities_add_distributions( VALUE self, VALUE gdpa, VALUE gdpb ) {
   return pl_as_ruby_class( pl_add_distributions( pl_a, pl_b ), Probabilities );
 }
 
+/*
+ * @overload add_distributions_mult(m_a, pd_a, m_b, pd_b)
+ *   Combines two distributions with multipliers to create a third, that represents the distribution
+ *   created when adding weighted results together.
+ *   @param [Integer] m_a Weighting for first distribution
+ *   @param [GamesDice::Probabilities] pd_a First distribution
+ *   @param [Integer] m_b Weighting for second distribution
+ *   @param [GamesDice::Probabilities] pd_b Second distribution
+ *   @return [GamesDice::Probabilities]
+ */
 VALUE probabilities_add_distributions_mult( VALUE self, VALUE m_a, VALUE gdpa, VALUE m_b, VALUE gdpb ) {
   int mul_a, mul_b;
   ProbabilityList *pl_a;
@@ -797,17 +920,14 @@ VALUE probabilities_add_distributions_mult( VALUE self, VALUE m_a, VALUE gdpa, V
   return pl_as_ruby_class( pl_add_distributions_mult( mul_a, pl_a, mul_b, pl_b ), Probabilities );
 }
 
-VALUE probabilities_implemented_in( VALUE self ) {
-  return ID2SYM( rb_intern("c") );
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 //
 //  Setup Probabilities class for Ruby interpretter
 //
 
-void init_probabilities_class( VALUE ParentModule ) {
-  Probabilities = rb_define_class_under( ParentModule, "Probabilities", rb_cObject );
+void init_probabilities_class() {
+  VALUE GamesDice = rb_define_module("GamesDice");
+  Probabilities = rb_define_class_under( GamesDice, "Probabilities", rb_cObject );
   rb_define_alloc_func( Probabilities, pl_alloc );
   rb_define_method( Probabilities, "initialize", probabilities_initialize, 2 );
   rb_define_method( Probabilities, "initialize_copy", probabilities_initialize_copy, 1 );
@@ -828,7 +948,6 @@ void init_probabilities_class( VALUE ParentModule ) {
   rb_define_singleton_method( Probabilities, "for_fair_die", probabilities_for_fair_die, 1 );
   rb_define_singleton_method( Probabilities, "add_distributions", probabilities_add_distributions, 2 );
   rb_define_singleton_method( Probabilities, "add_distributions_mult", probabilities_add_distributions_mult, 4 );
-  rb_define_singleton_method( Probabilities, "implemented_in", probabilities_implemented_in, 0 );
   rb_define_singleton_method( Probabilities, "from_h", probabilities_from_h, 1 );
   return;
 }

data/ext/games_dice/probabilities.h

@@ -7,7 +7,7 @@
 
 #include <ruby.h>
 
-void init_probabilities_class( VALUE ParentModule );
+void init_probabilities_class();
 
 typedef struct _pd {
     int offset;

data/games_dice.gemspec

@@ -10,31 +10,23 @@ Gem::Specification.new do |gem|
   gem.version       = GamesDice::VERSION
   gem.authors       = ['Neil Slater']
   gem.email         = ['slobo777@gmail.com']
-  gem.description   = 'A library for simulating dice. Use it to construct dice-rolling systems used in role-playing and board games.'
-  gem.summary       = 'Simulates and explains dice rolls from simple "1d6" to complex "roll 7 ten-sided dice, take best 3,
-                        results of 10 roll again and add on".'
+  gem.description   = <<~GEMDESC
+    A library for simulating dice. Use it to construct dice-rolling systems used in role-playing and board games.
+  GEMDESC
+  gem.summary = <<~GEMSUMM
+    Simulates and explains dice rolls from simple "1d6" to complex "roll 7 ten-sided dice, take best 3,
+    results of 10 roll again and add on".
+  GEMSUMM
   gem.homepage      = 'https://github.com/neilslater/games_dice'
   gem.license       = 'MIT'
 
-  gem.required_ruby_version = '>= 2.6.0'
-  gem.add_development_dependency 'coveralls', '>= 0.6.7'
-  gem.add_development_dependency 'json', '>= 1.7.7'
-  gem.add_development_dependency 'rake', '>= 1.9.1'
-  gem.add_development_dependency 'rake-compiler', '>= 0.8.3'
-  gem.add_development_dependency 'rspec', '>= 2.13.0'
-  gem.add_development_dependency 'rubocop', '>= 1.2.1'
-  gem.add_development_dependency 'yard', '>= 0.8.6'
+  gem.required_ruby_version = '>= 3.3.0'
 
-  # Red Carpet renders README.md, and is optional even when developing the gem.
-  # However, it has a C extension, which will not work in JRuby. This only affects the gem build process, so
-  # is only really used in environments like Travis, and is safe to wrap like this in the gemspec.
-  gem.add_development_dependency 'redcarpet', '>=3.5.1' if RUBY_DESCRIPTION !~ /jruby/
+  gem.add_dependency 'parslet', '~> 2.0'
 
-  gem.add_dependency 'parslet', '>= 1.5.0'
-
-  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.files         = `git ls-files -z`.split("\0").select { |file| File.file?(file) }
   gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.extensions    = gem.files.grep(%r{/extconf\.rb$})
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
+  gem.metadata['rubygems_mfa_required'] = 'true'
 end