nerd_dice 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2652443ce77d0c00ceb8ec2cb15151d7b03a15bba2ad592c44bb3f080f2e613c
-  data.tar.gz: 1c91a3545d42ce5d5627ddb87169a05316cff352e4931e4b6970f92e2c17e98a
+  metadata.gz: a5edc034febc13a688b57e15a6254ee4523144a9619f95ade4af6284b59df578
+  data.tar.gz: c60102fe7b1cc8b4e09c290b2bdbb9c6602b8b6311fca595e930397f10db3ed0
 SHA512:
-  metadata.gz: 39909d95757e9ebf2fa6848e87350a09aeb3b00ee8791aecc50ae083b5e541b2f6426a7a5e280c530a594f6b39179a6f32e70ba053817115992608ee205f662d
-  data.tar.gz: b6fd6502fb2a5beb79d6367f71b7039800138edc4d366e8b6e05030acf56875a37f2124ebc18eab08e9575cb232eb07b15f5d6528ad49c55dd7b997525343f36
+  metadata.gz: 7097d5f6df166b480954546c6e8d8dd1b771bb67fe515093cb60a4d29aee4f3f6e244fa0eec3f099bbfb1bc2291fe9da91acda973080887cd94d98738d7ec240
+  data.tar.gz: 3fa7a50fe3b4217bf11e4335f9ecdce9118c432f3a5a542e36a2a9963ccd9defc602885478c782596fffe4c1a6e9a540dfdd9eb024ced1a839f44b2fbceaba1e

data/.rubocop.yml

@@ -12,7 +12,7 @@ require:
     - rubocop-rspec
 
 AllCops:
-  TargetRubyVersion: 2.7
+  TargetRubyVersion: 3.0
   # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop
   # to ignore them, so only the ones explicitly set in this file are enabled.
   #DisabledByDefault: true

data/CHANGELOG.md

@@ -1,8 +1,140 @@
 # Nerd Dice Changelog
 
-<img src="https://i.kym-cdn.com/photos/images/newsfeed/000/186/610/thankyou.png?1318726198" alt="Our CHANGELOG is in another castle" />
+## master \(unreleased\)
+### Added
+### Changed
+### Fixed
 
-## Legacy Branch: See master
-This is a legacy maintenance branch.
+## 0.5.0 \(2023-02-23\)
+### Added
+* Add Ruby 3.1 and 3.2 to GitHub actions
+* Add security policy to gem
+* Add contributing guidelines to project
+### Changed
+* Remove Ruby 2.7 from GitHub actions
+* Change minimum Ruby version to 3.0
+* Refactor RuboCop to enable new cops by default and delete redundant config
+* Update bundle for dependencies and development dependencies
+### Fixed
+* Remove hardcoded link from README
+* Fix cognitive complexity code smell in convenience_methods
+* Update expired gem signing certificate
 
-The [authoritative version of the CHANGELOG](https://github.com/statelesscode/nerd_dice/blob/master/CHANGELOG.md) is found on the master branch. All other release and maintenance branches are updated to point to master after being created.
+## 0.4.1 \(2023-02-23\)
+### Added
+* Add Ruby 3.1 and 3.2 to GitHub actions
+### Changed
+* Remove Ruby 2.7 from GitHub actions
+* Refactor RuboCop to enable new cops by default and delete redundant config
+* Update bundle for dependencies and development dependencies
+### Fixed
+* Remove hardcoded link from README
+* Fix cognitive complexity code smell in convenience_methods
+* Update expired gem signing certificate
+
+## 0.4.0 \(2021-10-23\)
+### Added
+* Add `NerdDice::ConvenienceMethods` method_missing mixin module that allows for dynamic invocation of patterns in the method name that get converted into calls to `NerdDice.roll_dice` or `NerdDice.total_dice` along with allowing the advantage/disadvantage mechanic or bonuses to be parsed from the method name. Full documentation of the module can be found in the [Convenience Methods Mixin](README.md#convenience-methods-mixin) section of the README.
+* Add exensive specs to support the ConvenienceMethods module
+### Changed
+* Replace `Benchmark.bmbm` with `Benchmark.bm` in the nerd_dice_benchmark
+* Add convenience_methods to nerd_dice_benchmark
+* Extend `NerdDice::ConvenienceMethods` into top-level module as class methods
+### Fixed
+* Fix typos and horizontal scrolling in README
+* Fix CodeClimate Code Smell on harvest_totals
+
+## 0.3.1 \(2023-02-23\)
+### Added
+* Add Ruby 3.1 and 3.2 to GitHub actions
+### Changed
+* Remove Ruby 2.7 from GitHub actions
+* Refactor RuboCop to enable new cops by default and delete redundant config
+* Update bundle for dependencies and development dependencies
+### Fixed
+* Remove hardcoded link from README
+* Update expired gem signing certificate
+
+## 0.3.0 \(2021-09-11\)
+### Added
+* Add new options to `NerdDice::Configuration`
+  - `ability_score_number_of_sides`
+  - `ability_score_dice_rolled`
+  - `ability_score_dice_kept`
+* Add `NerdDice.harvest_totals` method that takes in a collection and returns the results of calling `total` on each element
+* Add `NerdDice.roll_ability_scores` convenience method that returns an array of `DiceSet` objects based on options and/or configuration
+* Add `NerdDice.total_ability_scores` convenience method that returns an array of integers based on options and/or configuration
+* Add `NerdDice::Die` class that represents a single die object and mixes in the `Comparable` module
+* Add `NerdDice::DiceSet` class that represents a collection of `Die` objects and mixes in the `Enumerable` module
+* Add `NerdDice::SetsRandomizationTechnique` mixin module and include in the `DiceSet` and `Die` classes
+* Add `die_background_color` and `die_foreground_color` to `Configuration` class with defaults defined as constants
+* Add `NerdDice.roll_dice` method that behaves in a similar fashion to `total_dice` but returns a `DiceSet` object instead of an `Integer` and has additional optional arguments relating to the non-numeric attributes of the dice
+* Add `coveralls_reborn` to RSpec and GitHub actions
+* Add build badge to README
+* Add Code Climate maintainability integration and badge to README
+* Add `nerd_dice_benchmark` script to bin directory
+* Add GitHub Action CI build
+  - Run RSpec test suite, fail if specs fail, report coverage via Coveralls
+  - Run RuboCop and fail if violations
+  - Run benchmark suite and fail if outside of allowed ratios
+### Changed
+* Update RuboCop version and configuration
+* Break up the NerdDice source code file into several smaller files that are included by the module
+* Enforce that `NerdDice.configuration.ability_score_array_size` must be a positive duck-type integer
+### Fixed
+
+## 0.2.1 \(2023-02-23\)
+### Added
+* Add Ruby 3.1 and 3.2 to GitHub actions
+### Changed
+* Remove Ruby 2.7 from GitHub actions
+* Refactor RuboCop to enable new cops by default and delete redundant config
+* Update bundle for dependencies and development dependencies
+### Fixed
+* Remove hardcoded link from README
+* Update expired gem signing certificate
+
+## 0.2.0 \(2021-01-28\)
+### Added
+* Add ability to configure with `NerdDice.configure` block or `NerdDice.configuration`
+  - Configure `randomization_technique` as `:random_rand`, `:securerandom`, `:random_object`, or `randomized`
+  - Configure `refresh_seed_interval` to allow a periodic refresh of the seed
+* Add `randomization_technique` option to `NerdDice.total_dice` method keyword arguments
+* Add a lower-level `execute_die_roll` method that allows you to roll a single die with a generator specified
+* Add ability to manually refresh or specify seed with `:refresh_seed!` method
+### Changed
+* Change `opts = {}` final argument to use keyword args `**opts` in the `NerdDice.total_dice` method. Now the method can be called as follows:
+```ruby
+# old
+NerdDice.total_dice(20, 1, {bonus: 5})
+NerdDice.total_dice(6, 3, {bonus: 1})
+
+# new
+NerdDice.total_dice(20, bonus: 5)
+NerdDice.total_dice(6, 3, bonus: 1)
+```
+* Call `:to_i` on bonus instead of using `:is_a?` and raise ArgumentError in the `NerdDice.total_dice` method if it doesn't respond to `:to_i`
+* Added `securerandom` as an explicit dependency due to Ruby 3.x change to bundled gem
+* `total_dice` no longer calls unqualified `.rand` which improves performance on all generators except for `:securerandom`
+### Fixed
+
+## 0.1.2 \(2023-02-23\)
+### Added
+### Changed
+* Refactor RuboCop to enable new cops by default and delete redundant config
+* Update bundle for dependencies and development dependencies
+### Fixed
+* Remove hardcoded link from README
+* Update expired gem signing certificate
+
+## 0.1.1 \(2020-12-12\)
+### Added
+### Changed
+### Fixed
+* Fix broken link to CHANGELOG in gemspec
+* Fix RuboCop offenses from 0.1.0 and refactor specs
+
+## 0.1.0 \(2020-12-07\)
+
+### Added
+* Add NerdDice.total_dice class method with the ability to roll multiple polyhedral dice and add a bonus

data/CONTRIBUTING.md

@@ -0,0 +1,108 @@
+# Contributing to the NerdDice Project
+
+Thank you for visiting the NerdDice repository and for taking interest in collaborating on the project. The primary goal of this project is educational: we want to teach people how to code with [Ruby](https://www.ruby-lang.org/en/). This is a published gem on [RubyGems](https://rubygems.org/gems/nerd_dice) and can be used in other projects using the instructions outlined in the [README](README.md#installation).
+
+<a name="before-you-start"></a>
+## Before you start...
+Everything in this repository is intended to be made freely available via the [UNLICENSE](UNLICENSE.txt) and the [Creative Commons](https://creativecommons.org) [CC0 Public Domain Dedication](https://creativecommons.org/publicdomain/zero/1.0/). You can obviously submit feature requests and issues and participate in the discussions, but we can\'t accept anything into this repository and project unless you agree to make it available under the terms above. See the [legal](README.md#legal) section in the README for more information.
+
+### Coding Videos
+We make [coding videos](https://youtube.com/playlist?list=PL9kkbu1kLUeOnUtMpAnJOCtHdThx1Efkt) on our [YouTube channel](https://www.youtube.com/statelesscode) for the end-to-end of this project. If you collaborate on this project, you are consenting to potentially have the interaction featured in our videos. There is no guarantee or obligation to include your contribution or interaction in our videos, and we reserve the right to moderate inappropriate content at our own discretion.
+
+## Ways to Contribute
+There are numerous ways to contribute to this project, irrespective of your level of technical expertise. We\'ll flesh out the details and guidelines for each way to contribute below
+
+- **[Feature requests](#feature-requests)**
+- **[Bug reports](#bug-reports)**
+- **[Code contributions](#code-contributions)**
+- **[Documentation contributions](#documentation-contributions)**
+- **[Art, design and creative input](#art-design-creative-input)**
+
+<a name="feature-requests"></a>
+### Feature requests
+If you have an idea for a feature you would like to see in the NerdDice gem, feel free to [open an issue](https://github.com/statelesscode/nerd_dice/issues) in this GitHub repository. As an agile project, we strive to provide value. The better you can articulate your idea and the value it would bring to you as a user of the gem or including in your own project, it will help us determine whether or how to prioritize the idea.
+
+Once an issue is submitted, we will likely need to discuss and clarify the feature request via comments to refine and clarify the intent, scope, and value of the feature. Precisely articulating your original feature request will help reduce the back-and-forth necessary to evaluate the story for implementation.
+
+We can\'t guarantee that your feature request will be implemented or featured in a video, but truly welcome the collaboration and feedback of all who take interest.
+
+<a name="bug-reports"></a>
+### Bug reports
+The distinction between a feature and a bug can sometimes be murky. While a feature generally refers to a request for new functionality, a bug is related to existing functionality that is not working as intended. In order to better evaluate the bug for a fix, it is extremely helpful to follow the following format:
+#### Expected behavior
+How you as a user or a technical evaluator would expect the application to behave. Expectation is obviously subjective, but defining your expectations as a user can help to expose usability problems with the application. If you discover a bug, we warmly welcome you to [open an issue](https://github.com/statelesscode/nerd_dice/issues) in this GitHub repository unless it is a [security bug](#security-bugs) that could be exploited and is not suitable for public collaboration.
+
+**Examples:**
+- When I use the `roll_` convenience method with `plus` and `minus` I expect it to error out.
+- When I configure a randomization technique I expect that the configuration will persist until I change it or stop the Ruby interpreter
+- When I roll a 6-sided die, I expect to get a number between 1 and 6, inclusive
+
+#### Actual behavior
+The actual behavior is what really happens when you try to use your feature in a way that defies your expectations. Using the same examples listed above, you can see how this might work.
+
+**Examples:**
+- The method doesn't error out and uses the plus but not the minus
+- The configuration always reverts the randomization technique to `:secure_random`
+- I sometimes get a 0 and I never get a 6
+
+#### Steps to reproduce
+In order to properly fix the bug, it needs to be reproducible. The more detailed and precise your steps to reproduce are, the more likely it will be that we come to the right solution in fixing the bug. Sometimes a bug will only manifest if an exact sequence of events takes place. The more complex an application gets, the harder it becomes to isolate and diagnose the root cause. An example of steps to reproduce the first problem can look something like this.
+- Include the gem in the `Gemfile` and run `bundle install`
+- Open the `Pry` console
+- Execute the following commands
+```ruby
+o = Object.new
+o.roll_2d8.harvest_totals
+```
+- A `NoMethodError` is raised
+
+In this case the `NoMethodError` is caused by improper usage of the `harvest_totals` method, but providing specifics about what you are trying to do and what you expect to have happen can result in better clarity of documentation or a new feature.
+
+<a name="security-bugs"></a>
+#### Security bugs
+If you discover a security vulnerability in the application that can be exploited, please follow our [security reporting process](SECURITY.md) instead of submitting a public issue.
+
+<a name="code-contributions"></a>
+### Code contributions
+At Stateless Code our motto is \"Code Along\" and we mean it. If you have a feature that you want to implement yourself and contribute to the project, or you see an item in the [project backlog](https://github.com/statelesscode/nerd_dice/projects/1) that you want to try and tackle yourself, you are encouraged to do so.
+#### Open an issue, if applicable
+If there's a brand new feature you want to propose, or you want to work on a backlog item that is not yet converted into an issue, you can [open an issue](https://github.com/statelesscode/nerd_dice/issues) in this GitHub repository as you would in the sections above.
+#### Fork the repository
+To work on your changes, you will want to [fork this repository](https://github.com/statelesscode/nerd_dice/fork) into a repo on your own account so you can work and iterate on your feature.
+#### Develop the feature
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+Once you have forked the repo, you can work to develop the contribution on your account. As you are working on your contribution you can commit as frequently as you'd like. \(We'll likely squash the commit down if and when it becomes time to merge the feature.\) In order to avoid rework, be sure to follow the [coding standards](#coding-standards) below. If the pull request is a candidate for merging, we will review the code and iterate on any feedback as needed.
+<a name="coding-standards"></a>
+#### Coding standards
+Just like [Ruby on Rails](https://rubyonrails.org/) is able to increase programmer happiness by using convention over configuration, it\'s important to follow a consistent set of conventions throughout the code base to make it more consistent and maintainable. Some of these standards are just preferences while others \(like writing good tests\) are indispensable. If you feel strongly that one of these conventions should be modified and have good reasons to back it up, cordial conversation in an [issue](https://github.com/statelesscode/nerd_dice/issues) can be productive. I don\'t have all the answers and am constantly learning and evolving as a programmer myself. Just don\'t be a jerk about it.
+##### Always cover your code with good tests!
+Whenever it\'s possible and feasible, we recommend using a test-driven development approach \(red, green, refactor\) . We have a video on [Why Test Driven Development](https://youtu.be/AGXfZP-EhKo) on our [YouTube channel](https://www.youtube.com/statelesscode) if you\'d like to learn more.
+- Write your failing test
+- Implement your change in the application code to make the test pass
+- Refactor your code
+
+Tests should be meaningful, failing without your code and passing only with your code. And the assertions you make about your code should be meaningful. **Covering code with a test that doesn\'t make meaningful assertions is worse than not covering your code at all.**
+
+##### Make sure the build will pass
+Before your pull request can be merged, we need to make sure the GitHub Actions build will not fail. The following criteria must be met:
+- `rubocop` needs to run without violations. If there is no way around a RuboCop violation, we can add disable-enable magic comments, but this should be seen as a last resort
+- The test suite needs to pass. Running `rspec spec` from the root of the project will run the unit tests
+- The code coverage can\'t decrease. This will cause the Coveralls check on the code to fail.
+##### Avoid cognitive complexity and giant methods
+One of the common mottoes in the Ruby ecosystem is Don\'t Repeat Yourself \(DRY\). You want to write small, reusable methods for your code instead of giant thousand line monstrosities with if-else ladders and nested loops with more if-else ladders. Breaking your code down into bite sized chunks makes it more maintainable and less bug prone. It also allows you to write smaller, more-targeted unit tests. \"Working, but ugly\" is a common early iteration condition of a feature, but before we merge it to the main branch, we want our end goal to be elegant, expressive, concise code.
+##### Write a good commit message
+When you\'re incrementally working on a story, it's fine to use the one-line `git commit -m "My commit message"` method of committing your code. When you squash it down at the end of the pull request, you want a good commit message for your contribution. There are many great resources on the internet about writing quality commit messages. [This one from cbeams](https://cbea.ms/git-commit/) is one of my favorites.
+<a name="documentation-contributions"></a>
+### Documentation contributions
+You don\'t need to be a programmer to contribute to the project! If you have suggestions for clarity on documentation for the project \(as small as fixing a typo or as big as setting up a Wiki category\) you are welcome to contribute. If you aren\'t interested in learning about GitHub, git, or the version control process, you can still [open an issue](https://github.com/statelesscode/nerd_dice/issues) in this GitHub repository and provide your content contributions there. Of course, if you are comfortable with the pull request process from the [code contributions](#code-contributions) section, you are welcome to do so. We just don\'t want that to be a barrier to entry.
+
+<a name="art-design-creative-input"></a>
+### Art, design and creative input
+If you have art, design, or other forms of creative input on the project that don\'t fit the above criteria, you can [open an issue](https://github.com/statelesscode/nerd_dice/issues) in this GitHub repository for that as well. As noted in the [Before you start...](#before-you-start) section, we can\'t accept any contributions unless you agree to match them to the repository standards of CC0 and/or the UNLICENSE.
+
+<a name="guidelines-for-etiquette"></a>
+## Guidelines for etiquette
+See the [Conduct](README.md#conduct) section in the README for more information.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nerd_dice (0.4.1)
+    nerd_dice (0.5.0)
       securerandom (~> 0.2, >= 0.2.2)
 
 GEM

data/README.md

@@ -4,9 +4,11 @@
 # NerdDice
 Nerd dice allows you to roll polyhedral dice and add bonuses as you would in a tabletop roleplaying game. You can choose to roll multiple dice and keep a specified number of dice such as rolling 4d6 and dropping the lowest for ability scores or rolling with advantage and disadvantage if those mechanics exist in your game.
 
+<a name="videos"></a>
 ## Educational Videos By Stateless Code
 The end-to-end process of developing this gem has been captured as [instructional videos](https://www.youtube.com/playlist?list=PL9kkbu1kLUeOnUtMpAnJOCtHdThx1Efkt). The videos are in a one-take style so that the mistakes along the way have troubleshooting and the concepts used to develop the gem are explained as they are covered.
 
+<a name="installation"></a>
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -23,6 +25,7 @@ Or install it yourself as:
 
     $ gem install nerd_dice
 
+<a name="usage"></a>
 ## Usage
 After the gem is installed, you can require it as you would any other gem.
 
@@ -30,9 +33,11 @@ After the gem is installed, you can require it as you would any other gem.
 require 'nerd_dice'
 ```
 
+<a name="module-methods-or-method-missing"></a>
 ### Module methods or a dynamic method_missing DSL
 There are two main patterns for using NerdDice in your project. You can invoke the module-level methods like `NerdDice.total_dice` or you can include the `NerdDice::ConvenienceMethods` module to your class \(or IRB \). Once mixed in, you can dynamically invoke methods like `roll_d20_with_advantage` or `total_3d8_plus5`. See the [Convenience Methods Mixin](#convenience-methods-mixin)  section for usage details.
 
+<a name="configuration"></a>
 ### Configuration
 You can customize the behavior of NerdDice via a configuration block as below or by assigning an individual property via the ```NerdDice.configuration.property = value``` syntax \(where ```property``` is the config property and ```value``` is the value you want to assign\)\. The available configuration options as well as their defaults, if applicable, are listed in the example configuration block below:
 
@@ -78,6 +83,7 @@ end
 ```
 **Note:** You cannot set `ability_score_dice_kept` greater than `ability_score_dice_rolled`. If you try to set `ability_score_dice_kept` higher than `ability_score_dice_rolled`, an error will be raised. If you set `ability_score_dice_rolled` _lower_ than the existing value of `ability_score_dice_kept`, no error will be thrown, but `ability_score_dice_kept` will be _**modified**_ to match `ability_score_dice_rolled` and a warning will be printed.
 
+<a name="bonus"></a>
 ### Rolling a number of dice and adding a bonus
 You can use two different methods to roll dice. The `total_dice` method returns an `Integer` representing the total of the dice plus any applicable bonuses. The `total_dice` method does not support chaining additional methods like `highest`, `lowest`, `with_advantage`, `with_disadvantage`. The `roll_dice` method returns a `DiceSet` collection object, and allows for chaining  the methods mentioned above and iterating over the individual `Die` objects. `NerdDice.roll_dice.total` and `NerdDice.total_dice` are roughly equivalent.
 
@@ -118,6 +124,7 @@ dice_set = NerdDice::DiceSet.new(6, 3, bonus: 2, randomization_technique: :rando
                        damage_type: 'psychic', foreground_color: '#FFF', background_color: '#0FF')
 
 ```
+<a name="available-options"></a>
 #### Available options for NerdDice::DiceSet objects
 There are a number of options that can be provided when initializing a `NerdDice::DiceSet` object after specifying the mandatory number of sides and the optional number of dice \(default: 1\). The list below provides the options and indicates whether they are cascaded to the Die objects in the collection.
 * `bonus` \(Duck-type Integer, _default: 0_\): Bonus or penalty to apply to the total after all dice are rolled.  _**Not applied** to Die objects_
@@ -126,6 +133,7 @@ There are a number of options that can be provided when initializing a `NerdDice
 * `foreground_color` \(String, _default: `NerdDice.configuration.die_foreground_color`_\): Intended foreground color to apply to the dice in the `DiceSet`. Should be a valid CSS color but is not validated or enforced and doesn\'t currently have any real functionality associated with it.   _**Applied** to Die objects by default with ability to modify_
 * `background_color` \(String, _default: `NerdDice.configuration.die_background_color`_\): Intended background color to apply to the dice in the `DiceSet`. Should be a valid CSS color but is not validated or enforced and doesn\'t currently have any real functionality associated with it.   _**Applied** to Die objects by default with ability to modify_
 
+<a name="properties-of-die-objects"></a>
 #### Properties of individual Die objects
 When initialized from a `DiceSet` object most of the properties of the `Die` object are inherited from the `DiceSet` object. In addition, there is an `is_included_in_total` public attribute that can be set to indicate whether the value of that particular die should be included in the total for its parent `DiceSet`. This property always starts out as true when the `Die` is initialized, but can be set to false.
 
@@ -144,6 +152,7 @@ die.value # =>  Integer between 1 and number_of_sides
 # Rolls/rerolls the Die, sets value to the result of the roll, and returns the new value
 die.roll # => Integer.
 ```
+<a name="iterating"></a>
 #### Iterating through dice in a DiceSet
 The `DiceSet` class mixes in the `Enumerable` module and the `Die` object mixes in the `Comparable` module. This allows you to iterate over the dice in the collection. The `sort` method on the dice will return the die objects in ascending value from lowest to highest.
 
@@ -165,6 +174,7 @@ dice_set.each do |die|
   # do other things
 end
 ```
+<a name="method-chaining"></a>
 #### Methods and method chaining on the DiceSet
 Since the DiceSet is an object, you can call methods that operate on the result returned and allow for things like the 5e advantage/disadvantage mechanic, the ability to re-roll all of the dice in the `DiceSet`, or to mark them all as included in the total.
 
@@ -203,7 +213,7 @@ dice_set.reroll_all!
 # include_all_dice! method
 dice_set.include_all_dice! # resets is_included_in_total to true for all Die objects
 ```
-
+<a name="ability-scores"></a>
 ### Rolling Ability Scores
 You can call `roll_ability_scores` or `total_ability_scores` to get back an array of `DiceSet` objects or `Integer` objects, respectively. The `total_ability_scores` method calls `total` on each `DiceSet` and returns those numbers with one value per ability score. The `Configuration` object defaults to 6 ability scores using a methodology of __4d6 drop the lowest__ by default.
 
@@ -244,6 +254,7 @@ NerdDice.roll_ability_scores(
 ```
 **Note:** If you try to call this method with `ability_score_dice_kept` greater than `ability_score_dice_rolled` an error will be raised.
 
+<a name="refreshing-seed"></a>
 ### Manually setting or refreshing the random generator seed
 For randomization techniques other than `:securerandom` you can manually set or refresh the generator's seed by calling the `refresh_seed!` method. This is automatically called at the interval specified in `NerdDice.configuration.refresh_seed_interval` if it is not nil.
 
@@ -261,8 +272,10 @@ NerdDice.refresh_seed!(randomization_technique:  :randomized,
 ```
 __NOTE:__ Ability to specify a seed is primarily provided for testing purposes. This makes all random numbers generated _transparently deterministic_ and should not be used if you want behavior approximating randomness.
 
+<a name="utility-methods"></a>
 ### Utility Methods
 
+<a name="harvest-totals"></a>
 #### Harvesting Totals from DiceSets
 The `harvest_totals` method take any collection of objects where each element responds to `total` and return an array of the results of the total method.
 ```ruby
@@ -281,11 +294,13 @@ totals_array = NerdDice.harvest_totals(totals_array)
 ### Convenience Methods Mixin
 NerdDice provides an optional mixin `NerdDice::ConvenienceMethods` that uses Ruby\'s `method_missing` metaprogramming pattern to allow you to roll any number of dice with bonuses and/or the advantage/disadvantage mechanic by dynamically responding to methods that you type that match the `roll_` or `total_` pattern.
 
+<a name="considerations-for-convenience-methods"></a>
 #### Considerations for ConvenienceMethods
 Before mixing in this method with a class, be aware of other `method_missing` gems that you are also mixing into your project and be sure to write robust tests. We have sought to use `method_missing` in a responsible manner that delegates back to the default implementation using `super` if the method does not match the `ConvenienceMethods` pattern, but there is no guarantee that other gems included in your project are doing the same. If you run into problems with the `ConvenienceMethods` module interacting with other `method_missing` gems, everything that the `ConvenienceMethods` module does can be replicated using the module\-level methods described above or by calling the convenience method on `NerdDice`.
 
 Once a particular method has been called, it will define that method so that the next time it will invoke the method directly instead of traversing up the call stack for `method_missing`, which improves performance. The method will remain defined for the duration of the Ruby interpreter process.
 
+<a name="magic-nerd-dice-class-methods"></a>
 #### Calling ConvenienceMethods as NerdDice class methods
 NerdDice extends the `ConvenienceMethods` module into the top-level module as class methods, so you can call the methods on the NerdDice module without needing to worry about the implications of extending it into your own class.
 ```ruby
@@ -294,7 +309,7 @@ require 'nerd_dice'
 NerdDice.roll_3d6_lowest2_minus1
 NerdDice.total_d20_with_advantage_p6
 ```
-
+<a name="mixing-in-convenience-methods"></a>
 #### Mixing in the ConvenienceMethods module
 To mix the NerdDice DSL into your class, make sure the gem is required if not already and then use `include NerdDice::ConvenienceMethods` as shown below:
 ```ruby
@@ -324,7 +339,7 @@ class OtherClass
 end
 OtherClass.roll_3d6_lowest2_minus1 # returns NerdDice::DiceSet
 ```
-
+<a name="convenience-methods-usage"></a>
 #### ConvenienceMethods usage examples
 Any invocation of `NerdDice.roll_dice` and `NerdDice.total_dice` can be duplicated using the `NerdDice::ConvenienceMethods` mixin. Here are some examples of what you can do with the return types and equivalent methods in the comments:
 
@@ -387,6 +402,7 @@ roll_d20_with_advantage # => DiceSet: NerdDice.roll_dice(20, 2).with_advantage(1
 # equal to total_2d20_with_advantage but more natural
 total_d20_with_advantage # => Integer: NerdDice.roll_dice(20, 2).with_advantage(1).total
 ```
+<a name="convenience-methods-error-handling"></a>
 #### ConvenienceMethods error handling
 * If you try to call with a plus and a minus, an Exception is raised
 * If you call with a bonus and a keyword argument and they don't match, an Exception is raised
@@ -397,17 +413,19 @@ roll_3d8_plus3 bonus: 1 # will raise NerdDice::Error with message about "Bonus i
 roll_d20_with_advantage_lowest # will raise NameError using super method_missing
 total_4d6_lowest3_highest2 # will raise NameError using super method_missing
 ```
+<a name="code-along"></a>
+## Code Along!
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+You can contribute to this project in a variety of ways. See the [CONTRIBUTING](CONTRIBUTING.md) page for more details. You don't need to be a programmer to contribute. We welcome [feature requests](CONTRIBUTING.md#feature-requests),  [bug reports](CONTRIBUTING.md#bug-reports),  [code contributions](CONTRIBUTING.md#code-contributions), and [documentation contributions](CONTRIBUTING.md#documentation-contributions) as well as [art, design and/or creative input](CONTRIBUTING.md#art-design-creative-input).
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+<a name="conduct"></a>
+## Conduct
 
-## Contributing
+Just be polite and courteous in your interactions. It is possible to disagree passionately about ideas without making it personal. You can make a point without using language that leads to escalation. Nobody working on this project is perfect. In the event that something goes wrong, seek forgiveness and reconciliation with one another. **[Mercy triumphs over judgment](https://www.biblegateway.com/passage/?search=James+2&version=ESV)**.
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/statelesscode/nerd_dice/issues. We welcome and encourage your participation in this open-source project. We welcome those of all backgrounds and abilities, but we refuse to adopt the Contributor Covenant for reasons outlined in [BURN_THE_CONTRIBUTOR_COVENANT_WITH_FIRE.md](BURN_THE_CONTRIBUTOR_COVENANT_WITH_FIRE.md)
+We welcome and encourage your participation in this open-source project. We welcome those of all backgrounds and abilities, but we refuse to adopt the Contributor Covenant or any similar code of conduct for reasons outlined in [BURN_THE_CONTRIBUTOR_COVENANT_WITH_FIRE](BURN_THE_CONTRIBUTOR_COVENANT_WITH_FIRE.md). We welcome those who disagree about codes of conduct to contribute to this project, but we want to make it abundantly clear that Code of Conduct Trolls have no power here.
 
+<a name="legal"></a>
 ## Unlicense, License, and Copyright
 
 The project is dual-licensed under the [MIT](https://opensource.org/licenses/MIT) license and the [UNLICENSE](https://unlicense.org/) \(with strong preference toward the UNLICENSE\)\. The content is released under [CC0](https://creativecommons.org/share-your-work/public-domain/cc0/) \(no rights reserved\). You are free to include it in its original form or modified with or without additional modification in your own project\.

data/SECURITY.md

@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported Versions
+
+As-of right now, the latest patch version of each minor version is supported, but versions earlier than `0.5.x` are deprecated and will not receive additional updates after their certificate expires on February 23, 2024.
+
+| Version | Supported                  | End of Life |
+| ------- | -------------------------- | ----------- |
+| 0.5.x   | :white_check_mark: Current |             |
+| 0.4.x   | :warning: Deprecated       | 2024-02-23  |
+| 0.3.x   | :warning: Deprecated       | 2024-02-23  |
+| 0.2.x   | :warning: Deprecated       | 2024-02-23  |
+| 0.1.x   | :warning: Deprecated       | 2024-02-23  |
+
+## Certificate Signing and Checksums
+
+The gem is currently released with a certificate so it can be installed with the `HighSecurity` policy. The SHA-256 and SHA-512 of each released version of the gem is kept in the `checksum` directory of the GitHub repository.
+
+## Reporting a Vulnerability
+
+Please report (suspected) security vulnerabilities to security@statelesscode.com. We make no guarantees related to turnaround time. If the issue is confirmed, we will release a patch as soon as possible depending on complexity and severity.

data/lib/nerd_dice/convenience_methods.rb

@@ -78,10 +78,10 @@ module NerdDice
   #     roll_d20_with_advantage_lowest # will raise NameError using super method_missing
   #     total_4d6_lowest3_highest2 # will raise NameError using super method_missing
   module ConvenienceMethods
-    DIS = /_(with_disadvantage|lowest)/.freeze
-    ADV = /_(with_advantage|highest)/.freeze
-    MOD = /(_p(lus)?\d+|_m(inus)?\d+)/.freeze
-    OVERALL_REGEXP = /\A(roll|total)_\d*d\d+((#{ADV}|#{DIS})\d*)?#{MOD}?\z/.freeze
+    DIS = /_(with_disadvantage|lowest)/
+    ADV = /_(with_advantage|highest)/
+    MOD = /(_p(lus)?\d+|_m(inus)?\d+)/
+    OVERALL_REGEXP = /\A(roll|total)_\d*d\d+((#{ADV}|#{DIS})\d*)?#{MOD}?\z/
 
     # Override of method_missing
     # * Attempts to match pattern to the regular expression matching the methods

data/lib/nerd_dice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NerdDice
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/nerd_dice.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   GEM_DESCRIPTION
   spec.homepage = "https://github.com/statelesscode/nerd_dice"
   spec.licenses = %w[Unlicense MIT]
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nerd_dice
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Michael Duchemin
@@ -188,11 +188,13 @@ files:
 - ".rubocop.yml"
 - BURN_THE_CONTRIBUTOR_COVENANT_WITH_FIRE.md
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- SECURITY.md
 - UNLICENSE.txt
 - bin/console
 - bin/generate_checksums
@@ -247,7 +249,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="