CHANGELOG.md

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

Makefile

@@ -1,16 +0,0 @@
-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,20 +1,16 @@
 # rollable
 
-Roll and parse dices
+TODO: Write a description here
 
-Works with crystal v1.0.0
+## Installation [![travis](https://travis-ci.org/Nephos/crystal_rollable.svg)](https://travis-ci.org/Nephos/crystal_rollable)
 
-## 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:
-    git: https://git.sceptique.eu/Sceptique/rollable
+    github: Nephos/crystal_rollable
-    branch: master
 ```
 
 
@@ -23,8 +19,7 @@ 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
 ```
 
 
@@ -34,7 +29,7 @@ TODO: Write development instructions here
 
 ## Contributing
 
-1. Fork it ( https://git.sceptique.eu/Sceptique/rollable/fork )
+1. Fork it ( https://github.com/Nephos/crystal_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)
@@ -42,4 +37,4 @@ TODO: Write development instructions here
 
 ## Contributors
 
-- [Sceptique](https://git.sceptique.eu/Sceptique) Arthur Poulet - creator, maintainer
+- [Nephos](https://github.com/Nephos) Arthur Poulet - creator, maintainer

shard.yml

@@ -1,9 +1,7 @@
 name: rollable
-version: 1.0.0
+version: 0.1.2
-
-crystal: 1.0.0
 
 authors:
-  - Arthur Poulet <arthur.poulet@sceptique.eu>
+  - Arthur Poulet <arthur.poulet@mailoo.org>
 
 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(Exception) { Rollable::Dice.new 1001, 20 }
+    expect_raises { Rollable::Dice.new 1001, 20 }
   end
 
   it "details" do
@@ -41,15 +41,12 @@ 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(Exception) { Rollable::Dice.parse("yolo") }
+    expect_raises { Rollable::Dice.parse("yolo") }
-    expect_raises(Exception) { Rollable::Dice.parse("1d6+1", true) }
+    expect_raises { Rollable::Dice.parse("1d6+1", true) }
-    expect_raises(Exception) { Rollable::Dice.parse("--1d4") }
+    expect_raises { Rollable::Dice.parse("--1d4") }
   end
 
   it "consume" do

spec/rollable/die.cr

@@ -3,8 +3,7 @@ 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)
-    Rollable::Die.new(20, true).should be_a(Rollable::Die)
+    expect_raises { Rollable::Die.new(1001) }
-    expect_raises(Exception) { Rollable::Die.new(1001) }
   end
 
   it "min, max, average" do
@@ -14,9 +13,6 @@ 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
@@ -24,7 +20,6 @@ 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
 
@@ -32,25 +27,18 @@ 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
@@ -58,16 +46,12 @@ 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
@@ -100,8 +84,5 @@ 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,31 +8,17 @@ describe Rollable::Roll do
     r.min.should eq 5
     r.max.should eq 24
     r.average.should eq 14.5
-    100.times do
+    10.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])
-    100.times do
+    10.times do
       t = r.test_details
       (1..6).includes?(t[0]).should eq true
       (1..6).includes?(t[1]).should eq true
@@ -54,12 +40,10 @@ 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(Exception) { Rollable::Roll.parse("yolo") }
+    expect_raises { 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,125 +3,119 @@ require "./is_rollable"
 require "./die"
 require "./fixed_value"
 
-# Not a front class. It is used to represent a tuple of die type and die amount
+module Rollable
-#
+  # A `Dice` is a amount of `Die`.
-# A `Dice` is a amount of `Die`.
+  # It is rollable exactly like a classic `Die`
-# It is rollable exactly like a classic `Die`
+  #
-#
+  # 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:
-# ```
-# 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:
   # ```
-  # Dice.parse("1d6").reverse # => -1d6
+  # 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
   # ```
-  def reverse : Dice
+  class Dice < IsRollable
-    Dice.new -@count, @die
+    MAX = 1000
-  end
+    @count : Int32
+    @die : Die
 
-  def reverse!
+    getter count, die
-    @die.reverse!
-    self
-  end
 
-  {% for ft in ["min", "max"] %}
+    def initialize(@count, @die)
-  def {{ ft.id }} : Int32
+      check_count!
-    @die.{{ ft.id }} * @count
+    end
-  end
 
-  def {{ (ft + "_details").id }} : Array(Int32)
+    # Create a `Dice` with "die_type" faces.
-    @count.times.to_a.map{ @die.{{ ft.id }} }
+    def initialize(@count, die_type : Int32)
-  end
+      @die = Die.new(1..die_type)
-  {% end %}
+      check_count!
+    end
 
-  # Roll an amount of `Dice` as specified, and return the sum
+    private def check_count!
-  def test : Int32
+      raise ParsingError.new "Cannot more than #{MAX} dice (#{@count})" if @count > MAX
-    @count.times.reduce(0) { |r, l| r + @die.test }
+      if @count < 0
-  end
+        @count = -@count
+        @die.reverse!
+      end
+      self
+    end
 
-  # Roll an amount of `Dice` as specified, and return the values
+    def count=(count : Int32)
-  def test_details : Array(Int32)
+      @count = count
-    @count.times.to_a.map { @die.test }
+      check_count!
-  end
+    end
 
-  def average : Float64
+    def clone
-    @die.average * @count
+      Dice.new(@count, @die.clone)
-  end
+    end
 
-  def average_details : Array(Float64)
+    delegate "fixed?", to: die
-    @count.times.to_a.map { @die.average }
+    delegate "negative?", to: die
-  end
 
-  def ==(right : Dice)
+    # Reverse the `Die` of the `Dice`.
-    @count == right.count && @die == right.die
+    #
-  end
+    # Example:
+    # ```
+    # Dice.parse("1d6").reverse # => -1d6
+    # ```
+    def reverse : Dice
+      Dice.new -@count, @die
+    end
 
-  {% for op in [">", "<", ">=", "<="] %}
+    def reverse!
-  def {{ op.id }}(right : Dice)
+      @die.reverse!
-    average != right.average ?
+      self
-    average {{ op.id }} right.average :
+    end
-    max != right.max ?
-    max {{ op.id }} right.max :
-    min {{ op.id }} right.min
-  end
-  {% end %}
 
-  def <=>(right : Dice) : Int32
+    {% for ft in ["min", "max"] %}
-    if average != right.average
+    def {{ ft.id }} : Int32
-      average - right.average > 0 ? 1 : -1
+      @die.{{ ft.id }} * @count
-    elsif max != right.max
+    end
-      max - right.max <=> 0
+
-    else
+    def {{ (ft + "_details").id }} : Array(Int32)
-      min - right.min <=> 0
+      @count.times.to_a.map{ @die.{{ ft.id }} }
+    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,76 +1,75 @@
 # coding: utf-8
 
-class Rollable::Dice
+module Rollable
-  # Returns the `Dice` and the string parsed from `str`, in a `NamedTuple`
+  class Dice
-  # with "str" and "dice" keys.
+    # Returns the `Dice` and the string parsed from `str`, in a `NamedTuple`
-  #
+    # with "str" and "dice" keys.
-  # - If "strict" is true, then the string must end following the regex
+    #
-  #   `\A(!)?\d+(d\d+)?\Z/i`
+    # - If "strict" is true, then the string must end following the regex
-  #
+    #   `\A\d+(d\d+)?\Z/i`
-  # - If "strict" is false, then the string doesn't have to finish following
+    #
-  #   the regexp.
+    # - If "strict" is false, then the string doesn't have to finish following
-  private def self.parse_string(str : String, strict = true) : NamedTuple(str: String, dice: Dice)
+    #   the regexp.
-    match = str.match(/\A(?<sign>-|\+)? *(?<exploding>!)?(?<count>\d+)(?:(?:d)(?<die>\d+))?#{strict ? "\\Z" : ""}/i)
+    private def self.parse_string(str : String, strict = true) : NamedTuple(str: String, dice: Dice)
-    raise ParsingError.new("Parsing Error: dice, near to '#{str}'") if match.nil?
+      match = str.match(/\A(?<sign>-|\+)? *(?<count>\d+)(?:(?:d)(?<die>\d+))?#{strict ? "\\Z" : ""}/i)
-    sign = (match["sign"]? || "+") == "+" ? 1 : -1
+      raise ParsingError.new("Parsing Error: dice, near to '#{str}'") if match.nil?
-    count = match["count"]
+      sign = (match["sign"]? || "+") == "+" ? 1 : -1
-    die = match["die"]?
+      count = match["count"]
-    exploding = match["exploding"]? ? true : false
+      die = match["die"]?
-    if die.nil?
+      if die.nil?
-      {str: match[0], dice: FixedValue.new_dice(sign * count.to_i)}
+        return {str: match[0], dice: FixedValue.new_dice(sign * count.to_i)}
-    else
+      else
-      {str: match[0], dice: Dice.new(sign * count.to_i, die.to_i, exploding)}
+        return {str: match[0], dice: Dice.new(sign * count.to_i, die.to_i)}
+      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.
+    #
-  # If strict is false, only the valid string is returned.
+    # Then, it returns the string read.
-  # ```
+    # If strict is false, only the valid string is returned.
-  # Dice.parse("1d6") {|dice| dice.roll } => "1d6"
+    def self.parse(str : String, strict = true) : String
-  # ```
+      data = parse_string(str, strict)
-  def self.parse(str : String, strict = true) : String
+      yield data[:dice]
-    data = parse_string(str, strict)
+      return data[:str]
-    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
 
-  # Return a string which represents the `Dice`
+    # Returns the `Dice` parsed. (see `#parse_string`)
-  #
+    def self.parse(str : String, strict = true) : Dice
-  # - If the value is fixed ```(n..n)```, then it return the @count * value
+      data = parse_string(str, strict)
-  # - Else, it just add the count before the `Dice` like "{count}{dice.to_s}"
+      return data[:dice]
-  def to_s : String
+    end
-    if fixed?
+
-      (negative? ? "-" : "") + (@count * @die.min).abs.to_s
+    # Returns the unconsumed string.
-    else
+    #
-      (negative? ? "-" : "") + "#{@count}" + (negative? ? @die.reverse : @die).to_s
+    # 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
+
+    # 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,162 +1,119 @@
 require "./is_rollable"
 
-# Not a front class. It is used to represent a type of dice with faces
+module Rollable
-#
+  # A `Die` is a range of Integer values.
-# A `Die` is a range of Integer values.
+  # It is rollable.
-# 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:
   # ```
-  # Die.new(1..6).reverse # => Die.new -6..-1
+  # d = Die.new(1..6)
+  # d.min     # => 1
+  # d.max     # => 6
+  # d.average # => 3.5
+  # d.test    # => a random value included in 1..6
   # ```
-  def reverse : Die
+  # TODO: make it a Struct ?
-    Die.new -@faces.end..-@faces.begin, @exploding
+  class Die < IsRollable
-  end
+    MAX = 1000
+    @faces : Range(Int32, Int32)
 
-  def reverse!
+    getter faces
-    @faces = -@faces.end..-@faces.begin
-    self
-  end
 
-  def max : Int32
+    def initialize(@faces)
-    if @exploding
+      raise ParsingError.new "Cannot die with more than #{MAX} faces (#{@faces})" if @faces.size > MAX
-      @faces.end * EXPLODING_ITERATIONS
+    end
-    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
-    proba = @faces.size.to_f64
+      @faces.reduce { |r, l| r + l }.to_f64 / @faces.size
-    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
-    string = if self.size == 1
+      if self.size == 1
-               min.to_s
+        min.to_s
-             elsif self.min == 1
+      elsif self.min == 1
-               "D#{@faces.end}"
+        "D#{self.max}"
-             else
+      else
-               "D(#{@faces.begin},#{@faces.end})"
+        "D(#{self.min},#{self.max})"
-             end
+      end
-    string = "!#{string}" if @exploding
+    end
-    return string
-  end
 
-  def ==(right : Die)
+    def ==(right : Die)
-    @faces == right.faces && @exploding == right.exploding
+      @faces == right.faces
-  end
+    end
 
-  {% for op in [">", "<", ">=", "<="] %}
+    {% for op in [">", "<", ">=", "<="] %}
-  def {{ op.id }}(right : Die)
+    def {{ op.id }}(right : Die)
-    return false if @exploding != right.exploding
+      average != right.average ?
-    average != right.average ?
+      average {{ op.id }} right.average :
-    average {{ op.id }} right.average :
+      max != right.max ?
-    max != right.max ?
+      max {{ op.id }} right.max :
-    max {{ op.id }} right.max :
+      min {{ op.id }} right.min
-    min {{ op.id }} right.min
+    end
-  end
+    {% end %}
-  {% end %}
 
-  def <=>(right : Die) : Int32
+    def <=>(right : Die)
-    if average != right.average
+      average != right.average ? average - right.average <=> 0 : max != right.max ? max - right.max <=> 0 : min - right.min <=> 0
-      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,22 +1,24 @@
 require "./die"
 
-# Allows to create a die with a fixed value.
+module Rollable
-# The die will only gives this value everytime.
+  # Allow to create a die with a fixed value.
-# (`.min`, `.max`, `.test`, `.average`)
+  # The die will only gives this value everytime.
-#
+  # (`.min`, `.max`, `.test`, `.average`)
-# This is equivalent to
+  #
-# ```
+  # This is equivalent to
-# Die.new(n..n)              # => FixedValue.new_die n
+  # ```
-# Dice.new(1, Die.new(n..n)) # => FixedValue.new_dice n
+  # Die.new(n..n)              # => FixedValue.new_die n
-# ```
+  # Dice.new(1, Die.new(n..n)) # => FixedValue.new_dice n
-module Rollable::FixedValue
+  # ```
-  # Return a `Die` with only one face.
+  module FixedValue
-  def self.new_die(value : Int32)
+    # Return a `Die` with only one face.
-    Die.new value..value
+    def self.new_die(value : Int32)
-  end
+      Die.new value..value
+    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,6 +1,8 @@
-abstract class Rollable::IsRollable
+module Rollable
-  abstract def min : Int32
+  abstract class IsRollable
-  abstract def max : Int32
+    abstract def min : Int32
-  abstract def average : Float64
+    abstract def max : Int32
-  abstract def test : Int32
+    abstract def average : Int32
+    abstract def test : Int32
+  end
 end

src/rollable/roll.cr

@@ -3,153 +3,149 @@ require "./die"
 require "./fixed_value"
 require "./dice"
 
-# `Roll` is a list of `Dice`.
+module Rollable
-#
+  # `Roll` is a list of `Dice`.
-# 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 rollable, making the sum of each `Dice` values.
-# `.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:
-# ```
-# 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:
   # ```
-  # Roll.parse("1d6").reverse # => -1d6
+  # 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
   # ```
-  def reverse : Roll
+  class Roll < IsRollable
-    Roll.new @dice.map { |die| die.reverse }
+    @dice : Array(Dice)
-  end
 
-  {% for ft in ["min", "max", "test"] %}
+    getter dice
-  def {{ ft.id }} : Int32
-    @dice.reduce(0) { |r, l| r + l.{{ ft.id }} }
-  end
 
-  def {{ (ft + "_details").id }} : Array(Int32)
+    def initialize(@dice)
-    @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 order!
+    def clone
-    @dice.sort! { |a, b| b <=> a }
+      Roll.new(@dice.clone)
-    self
+    end
-  end
 
-  def order
+    delegate size, to: @dice
-    clone.order!
-  end
 
-  # let a [1d6, 1d4, 1d6, 2, 2d6]
+    # Reverse the values of the `Roll`.
-  # first, we copy it
+    def reverse! : Roll
-  # for 1d6 we check evey d6 in the copy, fetch and delete them
+      @dice.each { |die| die.reverse! }
-  def compact!
+      self
-    i = 0
+    end
-    until i >= @dice.size
+
-      # fetch the current dice
+    # Return a reversed copy of the  `Roll`'s values.
-      dice_current = @dice[i]
+    #
-      dice_type = dice_current.die
+    # Example:
-      dice_count = dice_current.count
+    # ```
-      # fetch all dice with the same type
+    # Roll.parse("1d6").reverse # => -1d6
-      j = @dice.size
+    # ```
-      until i >= j - 1
+    def reverse : Roll
-        j = j - 1
+      Roll.new @dice.map { |die| die.reverse }
-        if @dice[j].die == dice_type
+    end
-          @dice[i].count += @dice[j].count
+
-        elsif @dice[j].die == dice_type.reverse
+    {% for ft in ["min", "max", "test"] %}
-          @dice[i].count -= @dice[j].count
+    def {{ ft.id }} : Int32
-        else
+      @dice.reduce(0) { |r, l| r + l.{{ ft.id }} }
-          next
+    end
+
+    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
-        @dice.delete_at j
+        i = i + 1
       end
-      i = i + 1
+      compact_fixed!
+      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
-
-  private def compact_empty!
-    i = @dice.size - 1
-    until i < 0
-      @dice.delete_at(i) if @dice[i].count == 0
-      i = i - 1
     end
-  end
 
-  def compact
+    private def compact_empty!
-    clone.compact!
+      i = @dice.size - 1
+      until i < 0
+        @dice.delete_at(i) if @dice[i].count == 0
+        i = i - 1
+      end
+    end
+
+    def compact
+      clone.compact!
+    end
   end
 end
 

src/rollable/roll/parse_wrap.cr

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

src/rollable/version.cr

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