documentation: Update forge urls

possibility to catch the errors in a block

CHANGELOG.md

@@ -1,5 +1,8 @@
 # v0.1
 
+## v0.1.3
+- Minor improvements
+
 ## v0.1.2
 - Block DOS attack in the parser
 

Makefile

@@ -0,0 +1,16 @@
+NAME=`ls -d src/*/ | cut -f2 -d'/'`
+
+all: deps_opt test
+
+test:
+	crystal spec
+deps:
+	shards install
+deps_update:
+	shards update
+deps_opt:
+	@[ -d lib/ ] || make deps
+doc:
+	crystal docs
+
+.PHONY: all run build release test deps deps_update doc

README.md

@@ -1,16 +1,20 @@
 # rollable
 
-TODO: Write a description here
+Roll and parse dices
 
-## Installation [![travis](https://travis-ci.org/Nephos/crystal_rollable.svg)](https://travis-ci.org/Nephos/crystal_rollable)
+Works with crystal v1.0.0
 
+## Installation
+
+[![travis](https://travis-ci.org/Nephos/crystal_rollable.svg)](https://travis-ci.org/Nephos/crystal_rollable)
 
 Add this to your application's `shard.yml`:
 
 ```yaml
 dependencies:
   rollable:
-    github: Nephos/crystal_rollable
+    git: https://git.sceptique.eu/Sceptique/rollable
+    branch: master
 ```
 
 
@@ -19,7 +23,8 @@ dependencies:
 
 ```crystal
 require "rollable"
-Rollable::Roll.parse("2d6+4").test # => roll 2 dices and add 4 to the sum
+Rollable::Roll.parse("2d6+4").test # => Roll 2 dices and add 4 to the sum
+Rollable::Roll.parse("!1d20 + !1d8").test # => Exploding dices
 ```
 
 
@@ -29,7 +34,7 @@ TODO: Write development instructions here
 
 ## Contributing
 
-1. Fork it ( https://github.com/Nephos/crystal_rollable/fork )
+1. Fork it ( https://git.sceptique.eu/Sceptique/rollable/fork )
 2. Create your feature branch (git checkout -b my-new-feature)
 3. Commit your changes (git commit -am 'Add some feature')
 4. Push to the branch (git push origin my-new-feature)
@@ -37,4 +42,4 @@ TODO: Write development instructions here
 
 ## Contributors
 
-- [Nephos](https://github.com/Nephos) Arthur Poulet - creator, maintainer
+- [Sceptique](https://git.sceptique.eu/Sceptique) Arthur Poulet - creator, maintainer

shard.yml

@@ -1,7 +1,9 @@
 name: rollable
-version: 0.1.2
+version: 1.0.0
+
+crystal: 1.0.0
 
 authors:
-  - Arthur Poulet <arthur.poulet@mailoo.org>
+  - Arthur Poulet <arthur.poulet@sceptique.eu>
 
 license: MIT

spec/rollable/dice.cr

@@ -5,7 +5,7 @@ describe Rollable::Dice do
     d.min.should eq 2
     d.max.should eq 40
     d.average.should eq 21
-    expect_raises { Rollable::Dice.new 1001, 20 }
+    expect_raises(Exception) { Rollable::Dice.new 1001, 20 }
   end
 
   it "details" do
@@ -41,12 +41,15 @@ describe Rollable::Dice do
     Rollable::Dice.parse("-1d6").min.should eq -6
     Rollable::Dice.parse("-1d6").max.should eq -1
     Rollable::Dice.parse("-1d6").count.should eq 1
+    Rollable::Dice.parse("!1d6").count.should eq 1
+    Rollable::Dice.parse("!1d6").min.should eq 1
+    Rollable::Dice.parse("!1d6").max.should eq Rollable::Die.new(1..6, true).max
   end
 
   it "parse (error)" do
-    expect_raises { Rollable::Dice.parse("yolo") }
+    expect_raises(Exception) { Rollable::Dice.parse("yolo") }
-    expect_raises { Rollable::Dice.parse("1d6+1", true) }
+    expect_raises(Exception) { Rollable::Dice.parse("1d6+1", true) }
-    expect_raises { Rollable::Dice.parse("--1d4") }
+    expect_raises(Exception) { Rollable::Dice.parse("--1d4") }
   end
 
   it "consume" do

spec/rollable/die.cr

@@ -3,7 +3,8 @@ describe Rollable::Die do
     Rollable::Die.new(1..20).should be_a(Rollable::Die)
     Rollable::Die.new(10..20).should be_a(Rollable::Die)
     Rollable::Die.new(20).should be_a(Rollable::Die)
-    expect_raises { Rollable::Die.new(1001) }
+    Rollable::Die.new(20, true).should be_a(Rollable::Die)
+    expect_raises(Exception) { Rollable::Die.new(1001) }
   end
 
   it "min, max, average" do
@@ -13,6 +14,9 @@ describe Rollable::Die do
     Rollable::Die.new(1..20).min.should eq 1
     Rollable::Die.new(1..20).max.should eq 20
     Rollable::Die.new(1..20).average.should eq 10.5
+    Rollable::Die.new(1..20, true).min.should eq 1
+    Rollable::Die.new(1..20, true).max.should eq 80
+    Rollable::Die.new(1..20, true).average.should eq (10.5*0.05**0 + 10.5*0.05**1 + 10.5*0.05**2 + 10.5*0.05**3).round(3)
   end
 
   it "test" do
@@ -20,6 +24,7 @@ describe Rollable::Die do
       min = rand 1..10
       max = rand min..20
       ((min..max).includes? Rollable::Die.new(min..max).test).should eq(true)
+      ((min..max*Rollable::Die::EXPLODING_ITERATIONS).includes? Rollable::Die.new(min..max, true).test).should eq(true)
     end
   end
 
@@ -27,18 +32,25 @@ describe Rollable::Die do
     Rollable::Die.new(1..20).like?(Rollable::Die.new(1..20)).should eq true
     Rollable::Die.new(1..20).like?(Rollable::Die.new(-20..-1)).should eq true
     Rollable::Die.new(1..20).like?(Rollable::Die.new(1..10)).should eq false
+    Rollable::Die.new(1..20, true).like?(Rollable::Die.new(1..20, false)).should eq true
   end
 
   it "negative?" do
     Rollable::Die.new(1..20).negative?.should eq false
     Rollable::Die.new(-1..20).negative?.should eq false
+    Rollable::Die.new(1..-20).negative?.should eq false
     Rollable::Die.new(-1..-20).negative?.should eq true
+    Rollable::Die.new(1..20, true).negative?.should eq false
+    Rollable::Die.new(-1..-20, true).negative?.should eq true
   end
 
   it "fixed?" do
     Rollable::Die.new(1..20).fixed?.should eq false
     Rollable::Die.new(1..1).fixed?.should eq true
     Rollable::Die.new(20..20).fixed?.should eq true
+    Rollable::Die.new(1).fixed?.should eq true
+    Rollable::Die.new(1..20, true).fixed?.should eq false
+    Rollable::Die.new(1, true).fixed?.should eq true
   end
 
   it "reverse" do
@@ -46,12 +58,16 @@ describe Rollable::Die do
     Rollable::Die.new(1..20).reverse.max.should eq -1
     Rollable::Die.new(1..1).reverse.min.should eq -1
     Rollable::Die.new(1..1).reverse.max.should eq -1
+    Rollable::Die.new(1..20, true).reverse.min.should eq -20
+    Rollable::Die.new(1..20, true).reverse.max.should eq -4
   end
 
   it "to_s" do
     Rollable::Die.new(1..20).to_s.should eq "D20"
     Rollable::Die.new(2..2).to_s.should eq "2"
     Rollable::Die.new(2..4).to_s.should eq "D(2,4)"
+    Rollable::Die.new(1..20, true).to_s.should eq "!D20"
+    Rollable::Die.new(2..4, true).to_s.should eq "!D(2,4)"
   end
 
   it "cmp" do
@@ -84,5 +100,8 @@ describe Rollable::Die do
     ((Rollable::Die.new(1..4) <=> Rollable::Die.new(1..4)) == 0).should eq true
     ((Rollable::Die.new(2..3) <=> Rollable::Die.new(1..4)) < 0).should eq true
     (Rollable::Die.new(2..6) == Rollable::Die.new(4..4)).should eq false
+
+    # TODO: (Rollable::Die.new(1..20, true) == Rollable::Die.new(1..20, false)).should eq false
+    # TODO: (Rollable::Die.new(1..20, true) > Rollable::Die.new(1..20, false)).should eq true
   end
 end

spec/rollable/roll.cr

@@ -8,17 +8,31 @@ describe Rollable::Roll do
     r.min.should eq 5
     r.max.should eq 24
     r.average.should eq 14.5
-    10.times do
+    100.times do
       (5..24).includes?(r.test).should eq true
     end
   end
 
+  it "initialize exploding" do
+    r = Rollable::Roll.new [
+      Rollable::Dice.new(1, 6, true),
+    ]
+    r.should be_a Rollable::Roll
+    min = 1
+    max = 6*Rollable::Die::EXPLODING_ITERATIONS
+    r.min.should eq min
+    r.max.should eq max
+    100.times do
+      (min..max).includes?(r.test).should eq true
+    end
+  end
+
   it "test (details)" do
     r = Rollable::Roll.new [Rollable::Dice.new(2, 6), Rollable::Dice.new(1, 4)]
     r.min_details.should eq([1, 1, 1])
     r.max_details.should eq([6, 6, 4])
     r.average_details.should eq([3.5, 3.5, 2.5])
-    10.times do
+    100.times do
       t = r.test_details
       (1..6).includes?(t[0]).should eq true
       (1..6).includes?(t[1]).should eq true
@@ -40,10 +54,12 @@ describe Rollable::Roll do
     r1.should be_a(Rollable::Roll)
     r1.min.should eq 6
     r1.max.should eq 16
+    (Rollable::Roll.parse("!2d6+4").average > Rollable::Roll.parse("2d6+4").average).should be_true
   end
 
   it "parse (error)" do
-    expect_raises { Rollable::Roll.parse("yolo") }
+    expect_raises(Exception) { Rollable::Roll.parse("yolo") }
+    Rollable::Roll.parse("yolo") { |_| true } rescue fail("must be catch in block")
   end
 
   it "parse (more)" do

src/rollable.cr

@@ -1,6 +1,6 @@
-require "./rollable/*"
-
 module Rollable
   class ParsingError < Exception
   end
 end
+
+require "./rollable/*"

src/rollable/dice.cr

@@ -3,119 +3,125 @@ require "./is_rollable"
 require "./die"
 require "./fixed_value"
 
-module Rollable
+# Not a front class. It is used to represent a tuple of die type and die amount
-  # A `Dice` is a amount of `Die`.
+#
-  # It is rollable exactly like a classic `Die`
+# A `Dice` is a amount of `Die`.
-  #
+# It is rollable exactly like a classic `Die`
-  # It is also possible to get the details of a roll, using the methods
+#
-  # `.min_details`, `.max_details`, `.average_details`, `.test_details`
+# It is also possible to get the details of a roll, using the methods
+# `.min_details`, `.max_details`, `.average_details`, `.test_details`
+#
+# Example:
+# ```
+# d = Dice.parse "2d6"
+# d.min         # => 2
+# d.max         # => 12
+# d.average     # => 7
+# d.min_details # => [1, 1]
+# d.test        # => the sum of 2 random values between 1..6
+# ```
+class Rollable::Dice < Rollable::IsRollable
+  MAX = 1000
+  @count : Int32
+  @die : Die
+
+  getter count, die
+
+  def initialize(@count, @die)
+    check_count!
+  end
+
+  # Create a `Dice` with "die_type" faces.
+  def initialize(@count, die_type : Int32, exploding : Bool = false)
+    @die = Die.new(1..die_type, exploding)
+    check_count!
+  end
+
+  private def check_count!
+    raise ParsingError.new "Cannot more than #{MAX} dice (#{@count})" if @count > MAX
+    if @count < 0
+      @count = -@count
+      @die.reverse!
+    end
+    self
+  end
+
+  def count=(count : Int32)
+    @count = count
+    check_count!
+  end
+
+  def clone
+    Dice.new(@count, @die.clone)
+  end
+
+  delegate "fixed?", to: die
+  delegate "negative?", to: die
+
+  # Reverse the `Die` of the `Dice`.
   #
   # Example:
   # ```
-  # d = Dice.parse "2d6"
+  # Dice.parse("1d6").reverse # => -1d6
-  # d.min         # => 2
-  # d.max         # => 12
-  # d.average     # => 7
-  # d.min_details # => [1, 1]
-  # d.test        # => the sum of 2 random values between 1..6
   # ```
-  class Dice < IsRollable
+  def reverse : Dice
-    MAX = 1000
+    Dice.new -@count, @die
-    @count : Int32
+  end
-    @die : Die
 
-    getter count, die
+  def reverse!
+    @die.reverse!
+    self
+  end
 
-    def initialize(@count, @die)
+  {% for ft in ["min", "max"] %}
-      check_count!
+  def {{ ft.id }} : Int32
-    end
+    @die.{{ ft.id }} * @count
+  end
 
-    # Create a `Dice` with "die_type" faces.
+  def {{ (ft + "_details").id }} : Array(Int32)
-    def initialize(@count, die_type : Int32)
+    @count.times.to_a.map{ @die.{{ ft.id }} }
-      @die = Die.new(1..die_type)
+  end
-      check_count!
+  {% end %}
-    end
 
-    private def check_count!
+  # Roll an amount of `Dice` as specified, and return the sum
-      raise ParsingError.new "Cannot more than #{MAX} dice (#{@count})" if @count > MAX
+  def test : Int32
-      if @count < 0
+    @count.times.reduce(0) { |r, l| r + @die.test }
-        @count = -@count
+  end
-        @die.reverse!
-      end
-      self
-    end
 
-    def count=(count : Int32)
+  # Roll an amount of `Dice` as specified, and return the values
-      @count = count
+  def test_details : Array(Int32)
-      check_count!
+    @count.times.to_a.map { @die.test }
-    end
+  end
 
-    def clone
+  def average : Float64
-      Dice.new(@count, @die.clone)
+    @die.average * @count
-    end
+  end
 
-    delegate "fixed?", to: die
+  def average_details : Array(Float64)
-    delegate "negative?", to: die
+    @count.times.to_a.map { @die.average }
+  end
 
-    # Reverse the `Die` of the `Dice`.
+  def ==(right : Dice)
-    #
+    @count == right.count && @die == right.die
-    # Example:
+  end
-    # ```
-    # Dice.parse("1d6").reverse # => -1d6
-    # ```
-    def reverse : Dice
-      Dice.new -@count, @die
-    end
 
-    def reverse!
+  {% for op in [">", "<", ">=", "<="] %}
-      @die.reverse!
+  def {{ op.id }}(right : Dice)
-      self
+    average != right.average ?
-    end
+    average {{ op.id }} right.average :
+    max != right.max ?
+    max {{ op.id }} right.max :
+    min {{ op.id }} right.min
+  end
+  {% end %}
 
-    {% for ft in ["min", "max"] %}
+  def <=>(right : Dice) : Int32
-    def {{ ft.id }} : Int32
+    if average != right.average
-      @die.{{ ft.id }} * @count
+      average - right.average > 0 ? 1 : -1
-    end
+    elsif max != right.max
-
+      max - right.max <=> 0
-    def {{ (ft + "_details").id }} : Array(Int32)
+    else
-      @count.times.to_a.map{ @die.{{ ft.id }} }
+      min - right.min <=> 0
-    end
-    {% end %}
-
-    # Roll an amount of `Dice` as specified, and return the sum
-    def test : Int32
-      @count.times.reduce(0) { |r, l| r + @die.test }
-    end
-
-    # Roll an amount of `Dice` as specified, and return the values
-    def test_details : Array(Int32)
-      @count.times.to_a.map { @die.test }
-    end
-
-    def average : Float64
-      @die.average * @count
-    end
-
-    def average_details : Array(Float64)
-      @count.times.to_a.map { @die.average }
-    end
-
-    def ==(right : Dice)
-      @count == right.count && @die == right.die
-    end
-
-    {% for op in [">", "<", ">=", "<="] %}
-    def {{ op.id }}(right : Dice)
-      average != right.average ?
-      average {{ op.id }} right.average :
-      max != right.max ?
-      max {{ op.id }} right.max :
-      min {{ op.id }} right.min
-    end
-    {% end %}
-
-    def <=>(right : Dice)
-      average != right.average ? average - right.average <=> 0 : max != right.max ? max - right.max <=> 0 : min - right.min <=> 0
     end
   end
 end

src/rollable/dice/parse_wrap.cr

@@ -1,75 +1,76 @@
 # coding: utf-8
 
-module Rollable
+class Rollable::Dice
-  class Dice
+  # Returns the `Dice` and the string parsed from `str`, in a `NamedTuple`
-    # Returns the `Dice` and the string parsed from `str`, in a `NamedTuple`
+  # with "str" and "dice" keys.
-    # with "str" and "dice" keys.
+  #
-    #
+  # - If "strict" is true, then the string must end following the regex
-    # - If "strict" is true, then the string must end following the regex
+  #   `\A(!)?\d+(d\d+)?\Z/i`
-    #   `\A\d+(d\d+)?\Z/i`
+  #
-    #
+  # - If "strict" is false, then the string doesn't have to finish following
-    # - If "strict" is false, then the string doesn't have to finish following
+  #   the regexp.
-    #   the regexp.
+  private def self.parse_string(str : String, strict = true) : NamedTuple(str: String, dice: Dice)
-    private def self.parse_string(str : String, strict = true) : NamedTuple(str: String, dice: Dice)
+    match = str.match(/\A(?<sign>-|\+)? *(?<exploding>!)?(?<count>\d+)(?:(?:d)(?<die>\d+))?#{strict ? "\\Z" : ""}/i)
-      match = str.match(/\A(?<sign>-|\+)? *(?<count>\d+)(?:(?:d)(?<die>\d+))?#{strict ? "\\Z" : ""}/i)
+    raise ParsingError.new("Parsing Error: dice, near to '#{str}'") if match.nil?
-      raise ParsingError.new("Parsing Error: dice, near to '#{str}'") if match.nil?
+    sign = (match["sign"]? || "+") == "+" ? 1 : -1
-      sign = (match["sign"]? || "+") == "+" ? 1 : -1
+    count = match["count"]
-      count = match["count"]
+    die = match["die"]?
-      die = match["die"]?
+    exploding = match["exploding"]? ? true : false
-      if die.nil?
+    if die.nil?
-        return {str: match[0], dice: FixedValue.new_dice(sign * count.to_i)}
+      {str: match[0], dice: FixedValue.new_dice(sign * count.to_i)}
-      else
+    else
-        return {str: match[0], dice: Dice.new(sign * count.to_i, die.to_i)}
+      {str: match[0], dice: Dice.new(sign * count.to_i, die.to_i, exploding)}
-      end
     end
+  end
 
-    # Return a valid string parsed from `str`. (see `#parse_string`)
+  # Return a valid string parsed from `str`. (see `#parse_string`)
-    #
+  #
-    # Yields the `Dice` parsed from `str`.
+  # Yields the `Dice` parsed from `str`.
-    #
+  # Then, it returns the string read.
-    # Then, it returns the string read.
+  # If strict is false, only the valid string is returned.
-    # If strict is false, only the valid string is returned.
+  # ```
-    def self.parse(str : String, strict = true) : String
+  # Dice.parse("1d6") {|dice| dice.roll } => "1d6"
-      data = parse_string(str, strict)
+  # ```
-      yield data[:dice]
+  def self.parse(str : String, strict = true) : String
-      return data[:str]
+    data = parse_string(str, strict)
+    yield data[:dice]
+    return data[:str]
+  end
+
+  # Returns the `Dice` parsed. (see `#parse_string`)
+  def self.parse(str : String, strict = true) : Dice
+    data = parse_string(str, strict)
+    return data[:dice]
+  end
+
+  # Returns the unconsumed string.
+  #
+  # Parse `str`, and yield a `Dice` parsed.
+  # It does not requires to be a full valid string
+  # (see #parse when strict is false).
+  # ```
+  # rest = Dice.consume("1d6+2") do |dice|
+  #   # dice = Dice.new(1, Die.new(1..6))
+  # end
+  # # rest = "+2"
+  # ```
+  def self.consume(str : String) : String?
+    str = str.strip
+    consumed = parse(str, false) do |dice|
+      yield dice
     end
+    return consumed.size >= str.size ? nil : str[consumed.size..-1]
+  end
 
-    # Returns the `Dice` parsed. (see `#parse_string`)
+  # Return a string which represents the `Dice`
-    def self.parse(str : String, strict = true) : Dice
+  #
-      data = parse_string(str, strict)
+  # - If the value is fixed ```(n..n)```, then it return the @count * value
-      return data[:dice]
+  # - Else, it just add the count before the `Dice` like "{count}{dice.to_s}"
-    end
+  def to_s : String
-
+    if fixed?
-    # Returns the unconsumed string.
+      (negative? ? "-" : "") + (@count * @die.min).abs.to_s
-    #
+    else
-    # Parse `str`, and yield a `Dice` parsed.
+      (negative? ? "-" : "") + "#{@count}" + (negative? ? @die.reverse : @die).to_s
-    # It does not requires to be a full valid string
-    # (see #parse when strict is false).
-    # ```
-    # rest = Dice.consume("1d6+2") do |dice|
-    #   # dice = Dice.new(1, Die.new(1..6))
-    # end
-    # # rest = "+2"
-    # ```
-    def self.consume(str : String) : String?
-      str = str.strip
-      consumed = parse(str, false) do |dice|
-        yield dice
-      end
-      return consumed.size >= str.size ? nil : str[consumed.size..-1]
-    end
-
-    # Return a string which represents the `Dice`
-    #
-    # - If the value is fixed ```(n..n)```, then it return the @count * value
-    # - Else, it just add the count before the `Dice` like "{count}{dice.to_s}"
-    def to_s : String
-      if fixed?
-        (negative? ? "-" : "") + (@count * @die.min).abs.to_s
-      else
-        (negative? ? "-" : "") + "#{@count}" + (negative? ? @die.reverse : @die).to_s
-      end
     end
   end
 end

src/rollable/die.cr

@@ -1,119 +1,162 @@
 require "./is_rollable"
 
-module Rollable
+# Not a front class. It is used to represent a type of dice with faces
-  # A `Die` is a range of Integer values.
+#
-  # It is rollable.
+# A `Die` is a range of Integer values.
+# It is rollable.
+#
+# Example:
+# ```
+# d = Die.new(1..6)
+# d.min     # => 1
+# d.max     # => 6
+# d.average # => 3.5
+# d.test    # => a random value included in 1..6
+# ```
+# TODO: make it a Struct ?
+class Rollable::Die < Rollable::IsRollable
+  MAX = 1000
+  EXPLODING_ITERATIONS = 4
+
+  @faces : Range(Int32, Int32)
+  getter exploding : Bool
+
+  getter faces
+
+  def initialize(@faces, @exploding = false)
+    raise ParsingError.new "Cannot die with more than #{MAX} faces (#{@faces})" if @faces.size > MAX
+    if @faces.end < @faces.begin
+      @faces = @faces.end..@faces.begin
+    end
+  end
+
+  def clone
+    Die.new(@faces, @exploding)
+  end
+
+  def initialize(nb_faces : Int32, @exploding = false)
+    raise ParsingError.new "Cannot die with more than #{MAX} faces (#{nb_faces})" if nb_faces > MAX
+    @faces = 1..nb_faces
+    if @faces.end < @faces.begin
+      @faces = @faces.end..@faces.begin
+    end
+  end
+
+  # Number of faces of the `Die`
+  def size
+    @faces.size
+  end
+
+  def fixed?
+    size == 1
+  end
+
+  def negative?
+    min < 0 && max < 0
+  end
+
+  def like?(other : Die)
+    @faces == other.faces || @faces == other.reverse.faces
+  end
+
+  # Reverse the values
   #
   # Example:
   # ```
-  # d = Die.new(1..6)
+  # Die.new(1..6).reverse # => Die.new -6..-1
-  # d.min     # => 1
-  # d.max     # => 6
-  # d.average # => 3.5
-  # d.test    # => a random value included in 1..6
   # ```
-  # TODO: make it a Struct ?
+  def reverse : Die
-  class Die < IsRollable
+    Die.new -@faces.end..-@faces.begin, @exploding
-    MAX = 1000
+  end
-    @faces : Range(Int32, Int32)
 
-    getter faces
+  def reverse!
+    @faces = -@faces.end..-@faces.begin
+    self
+  end
 
-    def initialize(@faces)
+  def max : Int32
-      raise ParsingError.new "Cannot die with more than #{MAX} faces (#{@faces})" if @faces.size > MAX
+    if @exploding
-    end
+      @faces.end * EXPLODING_ITERATIONS
-
+    else
-    def clone
-      Die.new(@faces)
-    end
-
-    def initialize(nb_faces : Int32)
-      raise ParsingError.new "Cannot die with more than #{MAX} faces (#{nb_faces})" if nb_faces > MAX
-      @faces = 1..nb_faces
-    end
-
-    # Number of faces of the `Die`
-    def size
-      @faces.size
-    end
-
-    def fixed?
-      size == 1
-    end
-
-    def negative?
-      min < 0 && max < 0
-    end
-
-    def like?(other : Die)
-      @faces == other.faces || @faces == other.reverse.faces
-    end
-
-    # Reverse the values
-    #
-    # Example:
-    # ```
-    # Die.new(1..6).reverse # => Die.new -6..-1
-    # ```
-    def reverse : Die
-      Die.new -max..-min
-    end
-
-    def reverse!
-      @faces = -max..-min
-      self
-    end
-
-    def max : Int32
       @faces.end
     end
+  end
 
-    def min : Int32
+  def min : Int32
-      @faces.begin
+    @faces.begin
+  end
+
+  private def explode(&block)
+    EXPLODING_ITERATIONS.times do |_|
+      value = @faces.to_a.sample
+      yield value
+      break if value != @faces.end
     end
+  end
 
-    # Return a random value in the range of the dice
+  # Return a random value in the range of the dice
-    def test : Int32
+  def test : Int32
+    if @exploding
+      sum = 0
+      explode { |value| sum += value }
+      sum
+    else
       @faces.to_a.sample
     end
+  end
 
-    # Mathematical expectation.
+  # Mathematical expectation.
-    #
+  #
-    # A d6 will have a expected value of 3.5
+  # A d6 will have a expected value of 3.5
-    def average : Float64
+  def average : Float64
-      @faces.reduce { |r, l| r + l }.to_f64 / @faces.size
+    proba = @faces.size.to_f64
+    non_exploding_average = @faces.reduce { |r, l| r + l }.to_f64 / proba
+    if @exploding
+      EXPLODING_ITERATIONS.times.reduce(0.0) {|base, i| base + non_exploding_average / proba ** i }.round(3)
+    else
+      non_exploding_average
     end
+  end
 
-    # Return a string.
+  # Return a string.
-    # - It may be a fixed value ```(n..n) => "#{n}"```
+  # - It may be a fixed value ```(n..n) => "#{n}"```
-    # - It may be a dice ```(1..n) => "D#{n}"```
+  # - It may be a dice ```(1..n) => "D#{n}"```
-    # - Else, ```(a..b) => "D(#{a},#{b})"```
+  # - Else, ```(a..b) => "D(#{a},#{b})"```
-    def to_s : String
+  def to_s : String
-      if self.size == 1
+    string = if self.size == 1
-        min.to_s
+               min.to_s
-      elsif self.min == 1
+             elsif self.min == 1
-        "D#{self.max}"
+               "D#{@faces.end}"
-      else
+             else
-        "D(#{self.min},#{self.max})"
+               "D(#{@faces.begin},#{@faces.end})"
-      end
+             end
-    end
+    string = "!#{string}" if @exploding
+    return string
+  end
 
-    def ==(right : Die)
+  def ==(right : Die)
-      @faces == right.faces
+    @faces == right.faces && @exploding == right.exploding
-    end
+  end
 
-    {% for op in [">", "<", ">=", "<="] %}
+  {% for op in [">", "<", ">=", "<="] %}
-    def {{ op.id }}(right : Die)
+  def {{ op.id }}(right : Die)
-      average != right.average ?
+    return false if @exploding != right.exploding
-      average {{ op.id }} right.average :
+    average != right.average ?
-      max != right.max ?
+    average {{ op.id }} right.average :
-      max {{ op.id }} right.max :
+    max != right.max ?
-      min {{ op.id }} right.min
+    max {{ op.id }} right.max :
-    end
+    min {{ op.id }} right.min
-    {% end %}
+  end
+  {% end %}
 
-    def <=>(right : Die)
+  def <=>(right : Die) : Int32
-      average != right.average ? average - right.average <=> 0 : max != right.max ? max - right.max <=> 0 : min - right.min <=> 0
+    if average != right.average
+      average - right.average > 0 ? 1 : -1
+    elsif max != right.max
+      max - right.max <=> 0
+    else
+      min - right.min <=> 0
     end
   end
 end
+#

src/rollable/fixed_value.cr

@@ -1,24 +1,22 @@
 require "./die"
 
-module Rollable
+# Allows to create a die with a fixed value.
-  # Allow to create a die with a fixed value.
+# The die will only gives this value everytime.
-  # The die will only gives this value everytime.
+# (`.min`, `.max`, `.test`, `.average`)
-  # (`.min`, `.max`, `.test`, `.average`)
+#
-  #
+# This is equivalent to
-  # This is equivalent to
+# ```
-  # ```
+# Die.new(n..n)              # => FixedValue.new_die n
-  # Die.new(n..n)              # => FixedValue.new_die n
+# Dice.new(1, Die.new(n..n)) # => FixedValue.new_dice n
-  # Dice.new(1, Die.new(n..n)) # => FixedValue.new_dice n
+# ```
-  # ```
+module Rollable::FixedValue
-  module FixedValue
+  # Return a `Die` with only one face.
-    # Return a `Die` with only one face.
+  def self.new_die(value : Int32)
-    def self.new_die(value : Int32)
+    Die.new value..value
-      Die.new value..value
+  end
-    end
 
-    # Return a `Dice` with only one face.
+  # Return a `Dice` with only one face.
-    def self.new_dice(fixed : Int32)
+  def self.new_dice(fixed : Int32)
-      Dice.new 1, FixedValue.new_die(fixed)
+    Dice.new 1, FixedValue.new_die(fixed)
-    end
   end
 end

src/rollable/is_rollable.cr

@@ -1,8 +1,6 @@
-module Rollable
+abstract class Rollable::IsRollable
-  abstract class IsRollable
+  abstract def min : Int32
-    abstract def min : Int32
+  abstract def max : Int32
-    abstract def max : Int32
+  abstract def average : Float64
-    abstract def average : Int32
+  abstract def test : Int32
-    abstract def test : Int32
-  end
 end

src/rollable/roll.cr

@@ -3,149 +3,153 @@ require "./die"
 require "./fixed_value"
 require "./dice"
 
-module Rollable
+# `Roll` is a list of `Dice`.
-  # `Roll` is a list of `Dice`.
+#
-  #
+# It is rollable, making the sum of each `Dice` values.
-  # It is rollable, making the sum of each `Dice` values.
+# It is also possible to get the details of a roll, using the methods
-  # It is also possible to get the details of a roll, using the methods
+# `.min_details`, `.max_details`, `.average_details`, `.test_details`
-  # `.min_details`, `.max_details`, `.average_details`, `.test_details`
+#
+# Example:
+# ```
+# r = Rollable.parse "1d6+2" # note: it also support "1d6 + 2"
+# r.min                      # => 3
+# r.max                      # => 9
+# r.average                  # => 5.5
+# r.test                     # => the sum of a random value in 1..6 and 2
+# ```
+class Rollable::Roll < Rollable::IsRollable
+  @dice : Array(Dice)
+
+  getter dice
+
+  def initialize(@dice)
+  end
+
+  def clone
+    Roll.new(@dice.clone)
+  end
+
+  delegate size, to: @dice
+
+  # Reverse the values of the `Roll`.
+  def reverse! : Roll
+    @dice.each { |die| die.reverse! }
+    self
+  end
+
+  # Return a reversed copy of the  `Roll`'s values.
   #
   # Example:
   # ```
-  # r = Rollable.parse "1d6+2" # note: it also support "1d6 + 2"
+  # Roll.parse("1d6").reverse # => -1d6
-  # r.min                      # => 3
-  # r.max                      # => 9
-  # r.average                  # => 5.5
-  # r.test                     # => the sum of a random value in 1..6 and 2
   # ```
-  class Roll < IsRollable
+  def reverse : Roll
-    @dice : Array(Dice)
+    Roll.new @dice.map { |die| die.reverse }
+  end
 
-    getter dice
+  {% for ft in ["min", "max", "test"] %}
+  def {{ ft.id }} : Int32
+    @dice.reduce(0) { |r, l| r + l.{{ ft.id }} }
+  end
 
-    def initialize(@dice)
+  def {{ (ft + "_details").id }} : Array(Int32)
+    @dice.map {|dice| dice.{{ (ft + "_details").id }} }.flatten
+  end
+  {% end %}
+
+  def average : Float64
+    @dice.reduce(0.0) { |r, l| r + l.average }
+  end
+
+  def average_details : Array(Float64)
+    @dice.map { |dice| dice.average_details }.flatten
+  end
+
+  def ==(right : Roll)
+    @dice.size == right.dice.size && @dice.map_with_index { |e, i| right.dice[i] == e }.all? { |e| e == true }
+  end
+
+  {% for op in [">", "<", ">=", "<="] %}
+  def {{ op.id }}(right : Roll)
+    average != right.average ?
+    average {{ op.id }} right.average :
+    max != right.max ?
+    max {{ op.id }} right.max :
+    min {{ op.id }} right.min
+  end
+  {% end %}
+
+  def <=>(right : Roll) : Int32
+    if average != right.average
+      average - right.average > 0 ? 1 : -1
+    elsif max != right.max
+      max - right.max <=> 0
+    else
+      min - right.min <=> 0
     end
+  end
 
-    def clone
+  def order!
-      Roll.new(@dice.clone)
+    @dice.sort! { |a, b| b <=> a }
-    end
+    self
+  end
 
-    delegate size, to: @dice
+  def order
+    clone.order!
+  end
 
-    # Reverse the values of the `Roll`.
+  # let a [1d6, 1d4, 1d6, 2, 2d6]
-    def reverse! : Roll
+  # first, we copy it
-      @dice.each { |die| die.reverse! }
+  # for 1d6 we check evey d6 in the copy, fetch and delete them
-      self
+  def compact!
-    end
+    i = 0
-
+    until i >= @dice.size
-    # Return a reversed copy of the  `Roll`'s values.
+      # fetch the current dice
-    #
+      dice_current = @dice[i]
-    # Example:
+      dice_type = dice_current.die
-    # ```
+      dice_count = dice_current.count
-    # Roll.parse("1d6").reverse # => -1d6
+      # fetch all dice with the same type
-    # ```
+      j = @dice.size
-    def reverse : Roll
+      until i >= j - 1
-      Roll.new @dice.map { |die| die.reverse }
+        j = j - 1
-    end
+        if @dice[j].die == dice_type
-
+          @dice[i].count += @dice[j].count
-    {% for ft in ["min", "max", "test"] %}
+        elsif @dice[j].die == dice_type.reverse
-    def {{ ft.id }} : Int32
+          @dice[i].count -= @dice[j].count
-      @dice.reduce(0) { |r, l| r + l.{{ ft.id }} }
+        else
-    end
+          next
-
-    def {{ (ft + "_details").id }} : Array(Int32)
-      @dice.map {|dice| dice.{{ (ft + "_details").id }} }.flatten
-    end
-    {% end %}
-
-    def average : Float64
-      @dice.reduce(0.0) { |r, l| r + l.average }
-    end
-
-    def average_details : Array(Float64)
-      @dice.map { |dice| dice.average_details }.flatten
-    end
-
-    def ==(right : Roll)
-      @dice.size == right.dice.size && @dice.map_with_index { |e, i| right.dice[i] == e }.all? { |e| e == true }
-    end
-
-    {% for op in [">", "<", ">=", "<="] %}
-    def {{ op.id }}(right : Roll)
-      average != right.average ?
-      average {{ op.id }} right.average :
-      max != right.max ?
-      max {{ op.id }} right.max :
-      min {{ op.id }} right.min
-    end
-    {% end %}
-
-    def <=>(right : Roll) : Int32
-      average != right.average ? average - right.average <=> 0 : max != right.max ? max - right.max <=> 0 : min - right.min <=> 0
-    end
-
-    def order!
-      @dice.sort! { |a, b| b <=> a }
-      self
-    end
-
-    def order
-      clone.order!
-    end
-
-    # let a [1d6, 1d4, 1d6, 2, 2d6]
-    # first, we copy it
-    # for 1d6 we check evey d6 in the copy, fetch and delete them
-    def compact!
-      i = 0
-      until i >= @dice.size
-        # fetch the current dice
-        dice_current = @dice[i]
-        dice_type = dice_current.die
-        dice_count = dice_current.count
-        # fetch all dice with the same type
-        j = @dice.size
-        until i >= j - 1
-          j = j - 1
-          if @dice[j].die == dice_type
-            @dice[i].count += @dice[j].count
-          elsif @dice[j].die == dice_type.reverse
-            @dice[i].count -= @dice[j].count
-          else
-            next
-          end
-          @dice.delete_at j
         end
-        i = i + 1
+        @dice.delete_at j
       end
-      compact_fixed!
+      i = i + 1
-      compact_empty!
-      self
     end
+    compact_fixed!
+    compact_empty!
+    self
+  end
 
-    private def compact_fixed!
+  private def compact_fixed!
-      fixed = @dice.map_with_index { |d, idx| {d, idx} }
+    fixed = @dice.map_with_index { |d, idx| {d, idx} }
-      fixed.select! { |t| t[0].die.fixed? }
+    fixed.select! { |t| t[0].die.fixed? }
-      idx = 0
+    idx = 0
-      fixed_dice = fixed.map do |t|
+    fixed_dice = fixed.map do |t|
-        @dice.delete_at(t[1] - idx)
+      @dice.delete_at(t[1] - idx)
-        idx = idx + 1
+      idx = idx + 1
-        t[0].max
+      t[0].max
-      end.sum
+    end.sum
-      @dice << FixedValue.new_dice(fixed_dice) if fixed_dice != 0
+    @dice << FixedValue.new_dice(fixed_dice) if fixed_dice != 0
-    end
+  end
 
-    private def compact_empty!
+  private def compact_empty!
-      i = @dice.size - 1
+    i = @dice.size - 1
-      until i < 0
+    until i < 0
-        @dice.delete_at(i) if @dice[i].count == 0
+      @dice.delete_at(i) if @dice[i].count == 0
-        i = i - 1
+      i = i - 1
-      end
     end
+  end
 
-    def compact
+  def compact
-      clone.compact!
+    clone.compact!
-    end
   end
 end
 

src/rollable/roll/parse_wrap.cr

@@ -1,51 +1,61 @@
-module Rollable
+class Rollable::Roll
-  class Roll
+  # Parse the string and return an array of `Dice`
-    # Parse the string and return an array of `Dice`
+  #
-    #
+  # see `Dice.consume`
-    # see `Dice.consume`
+  #
-    #
+  # The string passed as parameter is consumed, part by part, to create an
-    # The string passed as parameter is consumed, part by part, to create an
+  # Array of `Dice`. The string must follow grammar below (case insensitive):
-    # Array of `Dice`. The string must follow grammar below (case insensitive):
+  # ```text
-    # ```text
+  # - dice = [\d+][d][\d+]
-    # - dice = [\d+][d][\d+]
+  # - sign = ['+', '-']
-    # - sign = ['+', '-']
+  # - sdice = [sign]?[dice]
-    # - sdice = [sign]?[dice]
+  # - roll = [sign][dice][sdice]*
-    # - roll = [sign][dice][sdice]*
+  # ```
-    # ```
+  private def self.parse_str(str : String?, list : Array(Dice) = Array(Dice).new) : Array(Dice)
-    def self.parse_str(str : String?, list : Array(Dice) = Array(Dice).new) : Array(Dice)
+    return list if str.nil?
-      return list if str.nil?
+    str = str.strip
-      str = str.strip
+    sign = str[0]
-      sign = str[0]
+    if sign != '+' && sign != '-' && sign != '!' && !list.empty?
-      if sign != '+' && sign != '-' && !list.empty?
+      raise ParsingError.new("Parsing Error: roll, near to '#{str}'")
-        raise ParsingError.new("Parsing Error: roll, near to '#{str}'")
-      end
-      str = str[1..-1] if sign == '-' || sign == '+'
-      rest = Dice.consume(str) do |dice|
-        list << (sign == '-' ? dice.reverse : dice)
-      end
-      parse_str(rest, list)
-      return list
     end
-
+    str = str[1..-1] if sign == '-' || sign == '+'
-    # Parse the string "str" and returns a new `Roll` object
+    rest = Dice.consume(str) do |dice|
-    # see `#parse_str`
+      list << (sign == '-' ? dice.reverse : dice)
-    def self.parse(str : String) : Roll
-      return Roll.new(parse_str(str))
     end
+    parse_str(rest, list)
+    return list
+  end
 
-    def to_s : String
+  # Parse the string "str" and returns a new `Roll` object
-      @dice.reduce(nil) do |l, r|
+  #
-        # puts "l:#{l.to_s}, r:#{r.to_s}"
+  # see `#parse_str`
-        if l
+  def self.parse(str : String) : Roll
-          if r.negative?
+    return Roll.new(parse_str(str))
-            l + " - " + r.reverse.to_s
+  end
-          else
+
-            l + " + " + r.to_s
+  # Parse the string "str" and returns a new `Roll` object,
-          end
+  # and execute the "block" if an error occured
-        else
+  def self.parse(str : String) : Roll?
-          r.to_s
+    begin
-        end
+      return self.parse(str)
-      end.to_s
+    rescue err
+      yield err
+      return nil
     end
   end
+
+  def to_s : String
+    @dice.reduce(nil) do |l, r|
+      # puts "l:#{l.to_s}, r:#{r.to_s}"
+      if l
+        if r.negative?
+          l + " - " + r.reverse.to_s
+        else
+          l + " + " + r.to_s
+        end
+      else
+        r.to_s
+      end
+    end.to_s
+  end
 end

src/rollable/version.cr

@@ -1,3 +1,3 @@
 module Rollable
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end