die_roller 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d5579717cc87b41bbabb38aec9c014857cf7abb2902e3110cd598845f6aef53f
+  data.tar.gz: be29b17a1c8c292f52db055e419002ed677aabe288ab51fdb9eeeda622f2685f
+SHA512:
+  metadata.gz: ea71769eb678c7844edcccadc6b608557b24b6797fd28dcb5e94c256eea6fa85786bf7fe3b3c3f9b11a2be98ce072ffd5b9e85f455b76c5d7dff6fba657e211e
+  data.tar.gz: f287f78fd9d7dbccbc6838a07ec2e9853f7c7a756437d33724cf6039de65b6277ec46f04fce3fa0d36d88c049dc29a11b3aa2781db531b37e3fd66db51f4fb72

data/.rubocop.yml

@@ -0,0 +1,18 @@
+require:
+  - rubocop-minitest
+  - rubocop-rake
+
+AllCops:
+  TargetRubyVersion: 3.0
+  NewCops: enable
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-01-24
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Tony Drake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+# DieRoller
+
+`DieRoller` is a simple dice notation parser and roller written in pure Ruby.
+
+The gem supports the basic `AdX` dice roll notation (ie "2d6" meaning "2 6-sided dice").
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add die_roller
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install die_roller
+
+## Usage
+
+The main interface is through `DieRoller.roll` which takes a string containing only dice notation. Multiple dice may be defined deliminated by whitespace.
+
+Examples:
+
+```ruby
+DieRoller.roll("2d8")
+DieRoller.roll("2d8 4d6")
+DieRoller.roll(" 2d4  3d8")
+```
+
+If no number of dice are given, 1 is assumed:
+
+```ruby
+DieRoller.roll("d6") # Same as entering "1d6"
+```
+
+If parsing the string fails, `DieRoller::ParseError` will be raised:
+
+```sh
+> DieRoller.roll("1d6 badinput")
+=> Invalid input 'badinput' (DieRoller::ParseError)
+```
+
+At least 4 sides must be declared per die, else `DieRoller::DieSizeError` is raised:
+
+```sh
+> DieRoller.roll("3d3 1d6")
+=>  Die size too small for '3d3' (DieRoller::DieSizeError)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` 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`. 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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/t27duck/die_roller.
+
+Pull requests will only be accepted if they meet all the following criteria (ran by CI):
+
+1. Tests pass. This can be verified with:
+
+```
+$ bundle exec rake test
+```
+
+2. Code must conform to the [RuboCop rules](https://github.com/rubocop/rubocop#readme). This can be verified with:
+
+```
+$ bundle exec rake rubocop
+```
+
+3. RBS type signatures (in `sig/die_roller.rbs`). This can be verified with:
+
+```
+$ bundle exec rake steep
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+require "steep"
+require "steep/cli"
+
+desc "Type check with Steep"
+task :steep do
+  Steep::CLI.new(argv: ["check"], stdout: $stdout, stderr: $stderr, stdin: $stdin).run
+end
+
+task default: %i[test rubocop steep]

data/Steepfile

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# D = Steep::Diagnostic
+#
+# target :lib do
+#   signature "sig"
+#
+#   check "lib"                       # Directory name
+#   check "Gemfile"                   # File name
+#   check "app/models/**/*.rb"        # Glob
+#   # ignore "lib/templates/*.rb"
+#
+#   # library "pathname"              # Standard libraries
+#   # library "strong_json"           # Gems
+#
+#   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+#   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+#   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+#   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+#   # configure_code_diagnostics do |hash|             # You can setup everything yourself
+#   #   hash[D::Ruby::NoMethod] = :information
+#   # end
+# end
+
+# target :test do
+#   signature "sig", "sig-private"
+#
+#   check "test"
+#
+#   # library "pathname"              # Standard libraries
+# end
+
+target :lib do
+  signature "sig"
+  check "lib"
+  configure_code_diagnostics(Steep::Diagnostic::Ruby.default) # strict or all_error
+end

data/lib/die_roller/parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DieRoller
+  # Accpets a string input, and parses it for die tokens.
+  class Parser
+    attr_reader :tokens
+
+    def initialize(input)
+      generate_tokens(input)
+      validate_tokens
+    end
+
+    private
+
+    def generate_tokens(input)
+      @tokens = input.split.reject { |t| t == "" || t.nil? }.map(&:downcase)
+    end
+
+    def validate_tokens
+      @tokens.each do |token|
+        raise ParseError, "Invalid input '#{token}'" unless token.match?(DICE_SYNTAX_REGEX)
+      end
+    end
+  end
+
+  private_constant :Parser
+end

data/lib/die_roller/result.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DieRoller
+  # Holds the final result of rolls.
+  class Result
+    attr_reader :tokens, :rolls
+
+    def initialize(rolls:, tokens:)
+      @rolls = rolls
+      @tokens = tokens
+    end
+
+    def pairs
+      @pairs ||= dice.zip(values).map(&:freeze).freeze
+    end
+
+    def values
+      @values ||= @rolls.map(&:value).freeze
+    end
+
+    def dice
+      @dice ||= @rolls.map(&:die).freeze
+    end
+
+    def total
+      @total ||= @rolls.sum(&:value)
+    end
+  end
+
+  private_constant :Result
+end

data/lib/die_roller/roll.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DieRoller
+  # The result of a single die roll.
+  class Roll
+    attr_reader :sides, :value
+
+    def initialize(sides:, value:)
+      @sides = sides
+      @value = value
+    end
+
+    def die
+      "d#{sides}"
+    end
+  end
+
+  private_constant :Roll
+end

data/lib/die_roller/roller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DieRoller
+  # Responsible for rolling dice given `tokens` from a `DieRoller::Parser`.
+  class Roller
+    def self.roll(parser)
+      parser.tokens.map do |token|
+        numbers = token.split("d")
+        sides = numbers[1].to_i
+
+        raise DieSizeError, "Die size too small for '#{token}'" if sides < MINIMUM_DIE_SIZE
+
+        die_count = numbers[0].to_i
+        die_count = 1 if die_count.zero?
+        Array.new(die_count) { Roll.new(sides: sides, value: rand(sides) + 1) }
+      end.flatten
+    end
+  end
+
+  private_constant :Roller
+end

data/lib/die_roller/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DieRoller
+  VERSION = "0.1.0"
+end

data/lib/die_roller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "die_roller/version"
+require_relative "die_roller/parser"
+require_relative "die_roller/result"
+require_relative "die_roller/roll"
+require_relative "die_roller/roller"
+
+# A simple parser to roll one or more dice.
+#   DieRoller.roll("input")
+#
+#   Example valid inputs:
+#     "1d6"
+#     "d6" # Defaults to 1 die
+#     "2d8" # 2 8-sided dice
+#     "1d6 2d4" # 1 6-sided die and 2 4-sided dice
+#     "2D100"
+#
+#   Multiple dice can be separated with whitespace:
+#     "1d6 1d8"
+#
+#   `.roll` returns a `DieRoller::Result` object with info regarding the roll(s).
+module DieRoller
+  DICE_SYNTAX_REGEX = /\A\d*d\d+\z/
+  MINIMUM_DIE_SIZE = 4
+
+  class ParseError < StandardError; end
+  class DieSizeError < StandardError; end
+
+  def self.roll(input)
+    parser = Parser.new(input)
+    rolls = Roller.roll(parser)
+    Result.new(rolls: rolls, tokens: parser.tokens)
+  end
+end

data/sig/die_roll.rbs

@@ -0,0 +1,45 @@
+module DieRoller
+  VERSION: String
+  MINIMUM_DIE_SIZE: Integer
+  DICE_SYNTAX_REGEX: Regexp
+
+  class ParseError < StandardError
+  end
+
+  class DieSizeError < StandardError
+  end
+
+  class Roll
+    attr_reader sides: Array[String]
+    attr_reader value: Integer
+
+    def initialize: (sides: Integer, value: Integer) -> void
+    def die: -> String
+    def total: -> Integer
+  end
+
+  class Parser
+    attr_reader tokens: Array[String]
+
+    def initialize: (String) -> void
+
+    private
+    def generate_tokens: (String) -> void
+    def validate_tokens: -> void
+  end
+
+  class Roller
+    def self.roll: (Parser parser) -> Array[Roll]
+  end
+
+  class Result
+    attr_reader tokens: Array[String]
+    attr_reader rolls: Array[Roll]
+
+    def initialize: (rolls: Array[Roll], tokens: Array[String]) -> void
+    def pairs: -> Array[[String, (Integer | nil)]]
+    def dice: -> Array[String]
+    def values: -> Array[Integer]
+    def total: -> Integer
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: die_roller
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tony Drake
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-01-25 00:00:00.000000000 Z
+dependencies: []
+description: A simple dice notation parser and roller.
+email:
+- t27duck@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- lib/die_roller.rb
+- lib/die_roller/parser.rb
+- lib/die_roller/result.rb
+- lib/die_roller/roll.rb
+- lib/die_roller/roller.rb
+- lib/die_roller/version.rb
+- sig/die_roll.rbs
+homepage: https://github.com/t27duck/die_roller
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/t27duck/die_roller
+  source_code_uri: https://github.com/t27duck/die_roller
+  changelog_uri: https://github.com/t27duck/die_roller/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key: 
+specification_version: 4
+summary: A simple dice notation parser and roller.
+test_files: []