fizzbuzzer 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28811d471013230a977d03c106fb752a6367ebaf
-  data.tar.gz: 64f7fd56a9228ac13a81028d3c9f363b7120908c
+  metadata.gz: da58d7c29be8ab792904f6568b0accce17d2cf3c
+  data.tar.gz: 414323b0ae95450d79aa2d0da5be1c065470e57e
 SHA512:
-  metadata.gz: 7712b412f04216e2d143b258dc4c029924a27db4b9b26d63e992ef01bb787c848d03e7609ac78a2d7df53d5972fed4efb6e1731f218b03dbccc06722935488e9
-  data.tar.gz: b2fb9b151340b3a08af3d07cf1e8e97a68c80df108b2af4c44a55a59cddafd5e47cc9e32323cd9193a84a866d1d0eb9b1a7abca056b7e098bc6c3c0adff86507
+  metadata.gz: 4c75335ebca864f1d72568312fb813b53b16ef46fc79c01f3331bea11ce8b4fed9cc06ee17d10630986f135a919d1e84868c32de8845b5115ba63369b2a9aaf3
+  data.tar.gz: 86134a7767428e28906ce3539714265b8f7910c3a0ead9928dfa39e16288117e78993e67c499f4b56ee1379b50737561c0f4e1c72f70e1277737bab9e48aaac4

data/Manifest.txt

@@ -5,3 +5,6 @@ Rakefile
 bin/fizzbuzz
 lib/fizzbuzzer.rb
 lib/fizzbuzzer/version.rb
+test/helper.rb
+test/test_fizzbuzz.rb
+test/test_version.rb

data/README.md

@@ -1,9 +1,16 @@
 # FizzBuzzer
 
-fizzbuzzer - 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, Fizz Buzz, ... - a collection of algorithms for playing the word game for children that teaches division (one of the four basic arithmetic operations in mathematics)
-or helps you find the world's best coders in programming job interviews
-- are you (re)using the fizzbuzzer library? ;-) - don't reinvent the wheel or
-the feedbuzzer!
+fizzbuzzer - 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, Fizz Buzz, ... -
+a collection of algorithms for playing the word game for children that teaches division
+(one of the four basic arithmetic operations in mathematics)
+or helps you find the world's best coders in programming job interviews -
+are you (re)using the fizzbuzzer library? ;-) - don't reinvent the wheel or the feedbuzzer!
+
+
+* home  :: [github.com/rubylibs/fizzbuzzer](https://github.com/rubylibs/fizzbuzzer)
+* bugs  :: [github.com/rubylibs/fizzbuzzer/issues](https://github.com/rubylibs/fizzbuzzer/issues)
+* gem   :: [rubygems.org/gems/fizzbuzzer](https://rubygems.org/gems/fizzbuzzer)
+* rdoc  :: [rubydoc.info/gems/fizzbuzzer](http://rubydoc.info/gems/fizzbuzzer)
 
 
 
@@ -88,7 +95,347 @@ def fizzbuzz
 end
 ```
 
+### Classic
+
+``` ruby
+def fizzbuzz
+  (1..100).map do |n|
+      if n % 3 == 0 && n % 5 == 0
+        "FizzBuzz"
+      elsif n % 3 == 0
+        "Fizz"
+      elsif n % 5 == 0
+        "Buzz"
+      else
+        n
+      end
+  end
+end
+```
+
+Or use `zero?` and `n % 15` (3x5) for `n % 5 && n % 3`:
+
+``` ruby
+def fizzbuzz
+  (1..100).map do |n|
+      if    (n % 15).zero? then "FizzBuzz"
+      elsif (n % 3).zero?  then "Fizz"
+      elsif (n % 5).zero?  then "Buzz"
+      else   n
+      end
+  end
+end
+```
+
+Or use `case/when/else`:
+
+``` ruby
+def fizzbuzz
+  (1..100).map do |n|
+    case
+    when n % 3 == 0 && n % 5 == 0 then "FizzBuzz"
+    when n % 3 == 0 then "Fizz"
+    when n % 5 == 0 then "Buzz"
+    else n
+    end
+  end
+end
+```
+
+Or use `next` with `if`-clause:
+
+``` ruby
+def fizzbuzz
+  (1..100).map do |n|
+      next "FizzBuzz"   if n % 3 == 0 && n % 5 == 0
+      next "Fizz"       if n % 3 == 0
+      next "Buzz"       if n % 5 == 0
+      n
+  end
+end
+```
+
+
+### Monkey Patch (Extend) Fixnum Class
+
+``` ruby
+class Fixnum
+  def to_fizzbuzz
+    if self % 3 == 0 && self % 5 == 0
+      "FizzBuzz"
+    elsif self % 3 == 0
+      "Fizz"
+    elsif self % 5 == 0
+      "Buzz"
+    else
+      self
+    end
+  end
+end
+
+def fizzbuzz
+  (1..100).map { |n| n.to_fizzbuzz }
+end
+```
+
+## Object-Oriented with New Fizznum Class
+
+``` ruby
+class Fizznum
+  attr_accessor :num
+
+  def initialize(num)
+    self.num = num
+  end
+
+  def fizzbuzz?() num % 3 == 0 && num % 5 == 0;  end
+  def fizz?()     num % 3 == 0;  end
+  def buzz?()     num % 5 == 0;  end
+
+  def to_s
+    if    fizzbuzz? then "FizzBuzz"
+    elsif fizz?     then "Fizz"
+    elsif buzz?     then "Buzz"
+    else  num.to_s
+    end
+  end
+
+end
 
+def fizzbuzz
+  (1..100).map{ |n| Fizznum.new(n).to_s }
+end
+```
+
+
+### Don't Repeat Yourself (DRY)
+
+
+``` ruby
+FIZZ = 'Fizz'
+BUZZ = 'Buzz'
+
+def divisible_by?(numerator, denominator)
+  numerator % denominator == 0
+end
+
+def divisible_by_3?( numerator )
+  divisible_by?( numerator, 3 )
+end
+
+def divisible_by_5?( numerator )
+  divisible_by?( numerator, 5 )
+end
+
+def fizzbuzz
+  (1..100).map do |n|
+     fizz = divisible_by_3? n
+     buzz = divisible_by_5? n
+     case
+     when fizz && buzz then FIZZ + BUZZ
+     when fizz then FIZZ
+     when buzz then BUZZ
+     else n
+     end
+  end
+end
+```
+
+
+## Enumarator
+
+```ruby
+module FizzBuzz
+  def self.enumerator
+    Enumerator.new do |yielder|
+      (1..100).each do |n|
+        yielder << case
+                   when n % 3 == 0 && n % 5 == 0 then "FizzBuzz"
+                   when n % 3 == 0               then "Fizz"
+                   when n % 5 == 0               then "Buzz"
+                   else  n
+                   end
+      end
+    end
+  end
+end
+
+def fizzbuzz
+  FizzBuzz.enumerator.first( 100 )
+end
+```
+
+Or fetch every value one at a time with `next`:
+
+``` ruby
+def fizzbuzz
+  e = FizzBuzz.enumerator
+  [e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+   e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next]
+end
+```
+
+
+## Lazy Enumerator to Infinity
+
+```ruby
+require "bigdecimal"
+
+module FizzBuzz
+  def self.enumerator
+    Enumerator::Lazy.new(1..BigDecimal::INFINITY) do |yielder, n|
+       yielder << case
+                  when n % 3 == 0 && n % 5 == 0 then "FizzBuzz"
+                  when n % 3 == 0               then "Fizz"
+                  when n % 5 == 0               then "Buzz"
+                  else n
+                  end
+    end
+  end
+end
+
+def fizzbuzz
+  FizzBuzz.enumerator.take( 100 ).force      # or first( 100 ) is always eager by default
+end
+```
+
+
+
+## Pattern Matching with Noaidi
+
+``` ruby
+require "noaidi"
+
+def fizzbuzz
+  (1..100).map do |n|
+    Noaidi.match [n % 3, n % 5] do |m|
+      m.(0, 0)           { "FizzBuzz" }
+      m.(0, Fixnum)      { "Fizz" }
+      m.(Fixnum, 0)      { "Buzz" }
+      m.(Fixnum, Fixnum) { n }
+    end
+  end
+end
+```
+
+## Poor Man's (Do-It-Yourself) Pattern Matching
+
+``` ruby
+def fizzbuzz
+  (1..100).map do |n|
+    case [n % 3, n % 5].map {|remainder| remainder.zero? }
+    when [true, true]    then "FizzBuzz"
+    when [true, false]   then "Fizz"
+    when [false, true]   then "Buzz"
+    else n
+    end
+  end
+end
+```
+
+
+## Pattern Matching with dry-matcher
+
+``` ruby
+require "dry-matcher"
+
+FizzBuzz = Dry::Matcher.new(
+  fizzbuzz: Dry::Matcher::Case.new(
+              match: -> value { value % 3 == 0 && value % 5 == 0 },
+              resolve: -> value { "FizzBuzz" } ),
+  fizz:     Dry::Matcher::Case.new(
+              match: -> value { value % 3 == 0 },
+              resolve: -> value { "Fizz" } ),
+  buzz:     Dry::Matcher::Case.new(
+              match: -> value { value % 5 == 0 },
+              resolve: -> value { "Buzz" } ),
+  other:    Dry::Matcher::Case.new(
+              match: -> value { true },
+              resolve: -> value { value } ))
+
+def fizzbuzz
+  (1..100).map do |n|
+    FizzBuzz.(n) do |m|
+      m.fizzbuzz { |v| v }
+      m.fizz     { |v| v }
+      m.buzz     { |v| v }
+      m.other    { |v| v }
+    end
+  end
+end
+```
+
+
+## Rotate / No Conditionals
+
+``` ruby
+def fizzbuzz
+  fizzy = [1,0,0]
+  buzzy = [1,0,0,0,0]
+
+  (1..100).map do |n|
+     fizzy.rotate!
+     buzzy.rotate!
+     result = n.to_s * (1 - (fizzy[0] | buzzy[0]))
+     result << "Fizz" * fizzy[0]
+     result << "Buzz" * buzzy[0]
+     result
+  end
+end
+```
+
+Contributed by [John Schank](https://github.com/jschank).
+
+
+
+## With Parameterization
+
+``` ruby
+def fizzbuzz_engine(range, factors)
+  range.map do |n|
+    result = ""
+    factors.each do |(name, predicate)|
+      result << name if predicate.call(n)
+    end
+    result == "" ? n : result
+  end
+end
+
+def fizzbuzz
+  fizzbuzz_engine( 1..100, [["Fizz", -> n { n % 3 == 0 }],
+                            ["Buzz", -> n { n % 5 == 0 }]])
+end
+```
+
+Or with default configuration settings:
+
+``` ruby
+FIZZBUZZ_DEFAULT_RANGE    = 1..100
+FIZZBUZZ_DEFAULT_FACTORS  = [["Fizz", -> n { n % 3 == 0 }],
+                             ['Buzz', -> n { n % 5 == 0 }]]
+
+def fizzbuzz_engine(range=FIZZBUZZ_DEFAULT_RANGE, factors=FIZZBUZZ_DEFAULT_FACTORS)
+  range.map do |n|
+    result = ""
+    factors.each do |(name, predicate)|
+      result << name if predicate.call(n)
+    end
+    result == "" ? n : result
+  end
+end
+
+def fizzbuzz
+  fizzbuzz_engine
+end
+```
 
 
 

data/Rakefile

@@ -18,6 +18,8 @@ Hoe.spec 'fizzbuzzer' do
   self.history_file = 'HISTORY.md'
 
   self.extra_deps = [
+    ['noaidi'],
+    ['dry-matcher']
   ]
 
   self.licenses = ['Public Domain']

data/lib/fizzbuzzer.rb

@@ -2,11 +2,12 @@
 
 require 'pp'
 
-
 ## our own code
 require 'fizzbuzzer/version'    # note: let version always go first
 
 
+
+
 module FizzBuzzer
 
 module V1
@@ -23,7 +24,333 @@ module V1
   end
 end ## module V1
 
+module V2a
+  def fizzbuzz
+    (1..100).map do |n|
+      if n % 3 == 0 && n % 5 == 0
+        "FizzBuzz"
+      elsif n % 3 == 0
+        "Fizz"
+      elsif n % 5 == 0
+        "Buzz"
+      else
+        n
+      end
+    end
+  end
+end
+
+module V2b
+  def fizzbuzz
+    (1..100).map do |n|
+      if    (n % 15).zero? then "FizzBuzz"
+      elsif (n % 3).zero?  then "Fizz"
+      elsif (n % 5).zero?  then "Buzz"
+      else   n
+      end
+    end
+  end
+end
+
+module V2c
+  def fizzbuzz
+    (1..100).map do |n|
+      case
+      when n % 3 == 0 && n % 5 == 0 then "FizzBuzz"
+      when n % 3 == 0 then "Fizz"
+      when n % 5 == 0 then "Buzz"
+      else n
+      end
+    end
+  end
+end
+
+module V2d
+  def fizzbuzz
+    (1..100).map do |n|
+      next "FizzBuzz"   if n % 3 == 0 && n % 5 == 0
+      next "Fizz"       if n % 3 == 0
+      next "Buzz"       if n % 5 == 0
+      n
+    end
+  end
+end
+end # module FizzBuzzer
+
+
+
+## monkey patch for V3  - needs top level namespace
+##   todo/fix: use refinements - why? why not?
+class Fixnum
+  def to_fizzbuzz
+    if self % 3 == 0 && self % 5 == 0
+      "FizzBuzz"
+    elsif self % 3 == 0
+      "Fizz"
+    elsif self % 5 == 0
+      "Buzz"
+    else
+      self
+    end
+  end
+end
+
+
+module FizzBuzzer
+module V3
+  def fizzbuzz
+     (1..100).map { |n| n.to_fizzbuzz }
+  end
+end
+
+
+
+module V4
+class Fizznum
+  attr_accessor :num
+
+  def initialize(num)
+    self.num = num
+  end
+
+  def fizzbuzz?() num % 3 == 0 && num % 5 == 0;  end
+  def fizz?()     num % 3 == 0;  end
+  def buzz?()     num % 5 == 0;  end
+
+  def to_s
+    if    fizzbuzz? then "FizzBuzz"
+    elsif fizz?     then "Fizz"
+    elsif buzz?     then "Buzz"
+    else  num.to_s
+    end
+  end
+end
+
+def fizzbuzz
+  (1..100).map{ |n| Fizznum.new(n).to_s }
+end
+end
+
+
+module V5
+FIZZ = 'Fizz'
+BUZZ = 'Buzz'
+
+def divisible_by?(numerator, denominator)
+  numerator % denominator == 0
+end
+
+def divisible_by_3?( numerator )
+  divisible_by?( numerator, 3 )
+end
+
+def divisible_by_5?( numerator )
+  divisible_by?( numerator, 5 )
+end
+
+def fizzbuzz
+  (1..100).map do |n|
+     fizz = divisible_by_3? n
+     buzz = divisible_by_5? n
+     case
+     when fizz && buzz then FIZZ + BUZZ
+     when fizz then FIZZ
+     when buzz then BUZZ
+     else n
+     end
+  end
+end
+end
+
+
+module V6a
+  module FizzBuzz
+    def self.enumerator
+      Enumerator.new do |yielder|
+        (1..100).each do |n|
+          yielder << case
+                     when n % 3 == 0 && n % 5 == 0 then "FizzBuzz"
+                     when n % 3 == 0               then "Fizz"
+                     when n % 5 == 0               then "Buzz"
+                     else  n
+                     end
+        end
+      end
+    end
+  end
 
+  def fizzbuzz
+    FizzBuzz.enumerator.first( 100 )
+  end
+end
+
+
+module V6b
+  module FizzBuzz
+    def self.enumerator
+      Enumerator.new do |yielder|
+        (1..100).each do |n|
+          yielder << if    n % 3 == 0 && n % 5 == 0 then "FizzBuzz"
+                     elsif n % 3 == 0               then "Fizz"
+                     elsif n % 5 == 0               then "Buzz"
+                     else  n
+                     end
+        end
+      end
+    end
+  end
+
+  def fizzbuzz
+    e = FizzBuzz.enumerator
+    [e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next,
+     e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next, e.next]
+  end
+end
+
+
+module V7
+require "bigdecimal"
+
+module FizzBuzz
+  def self.enumerator
+    Enumerator::Lazy.new(1..BigDecimal::INFINITY) do |yielder, n|
+       yielder << case
+                  when n % 3 == 0 && n % 5 == 0 then "FizzBuzz"
+                  when n % 3 == 0               then "Fizz"
+                  when n % 5 == 0               then "Buzz"
+                  else n
+                  end
+    end
+  end
+end
+
+def fizzbuzz
+  FizzBuzz.enumerator.take( 100 ).force      # or first( 100 ) is always eager by default
+end
+end
+
+
+module V8
+require "noaidi"
+
+def fizzbuzz
+  (1..100).map do |n|
+    Noaidi.match [n % 3, n % 5] do |m|
+      m.(0, 0)           { "FizzBuzz" }
+      m.(0, Fixnum)      { "Fizz" }
+      m.(Fixnum, 0)      { "Buzz" }
+      m.(Fixnum, Fixnum) { n }
+    end
+  end
+end
+end
+
+
+module V9
+  def fizzbuzz
+    (1..100).map do |n|
+      case [n % 3, n % 5].map {|remainder| remainder.zero? }
+      when [true, true]    then "FizzBuzz"
+      when [true, false]   then "Fizz"
+      when [false, true]   then "Buzz"
+      else n
+      end
+    end
+  end
+end
+
+
+module V10
+require "dry-matcher"
+
+FizzBuzz = Dry::Matcher.new(
+  fizzbuzz: Dry::Matcher::Case.new(
+              match: -> value { value % 3 == 0 && value % 5 == 0 },
+              resolve: -> value { "FizzBuzz" } ),
+  fizz:     Dry::Matcher::Case.new(
+              match: -> value { value % 3 == 0 },
+              resolve: -> value { "Fizz" } ),
+  buzz:     Dry::Matcher::Case.new(
+              match: -> value { value % 5 == 0 },
+              resolve: -> value { "Buzz" } ),
+  other:    Dry::Matcher::Case.new(
+              match: -> value { true },
+              resolve: -> value { value } ))
+
+def fizzbuzz
+  (1..100).map do |n|
+    FizzBuzz.(n) do |m|
+      m.fizzbuzz { |v| v }
+      m.fizz     { |v| v }
+      m.buzz     { |v| v }
+      m.other    { |v| v }
+    end
+  end
+end
+end
+
+
+module V11
+def fizzbuzz
+  fizzy = [1,0,0]
+  buzzy = [1,0,0,0,0]
+
+  (1..100).map do |n|
+     fizzy.rotate!
+     buzzy.rotate!
+     result = n.to_s * (1 - (fizzy[0] | buzzy[0]))
+     result << "Fizz" * fizzy[0]
+     result << "Buzz" * buzzy[0]
+     result
+  end
+end
+end
+
+
+module V12a
+def fizzbuzz_engine(range, factors)
+  range.map do |n|
+    result = ""
+    factors.each do |(name, predicate)|
+      result << name if predicate.call(n)
+    end
+    result == "" ? n : result
+  end
+end
+
+def fizzbuzz
+  fizzbuzz_engine( 1..100, [["Fizz", -> n { n % 3 == 0 }],
+                            ["Buzz", -> n { n % 5 == 0 }]])
+end
+end
+
+module V12b
+FIZZBUZZ_DEFAULT_RANGE     = 1..100
+FIZZBUZZ_DEFAULT_FACTORS   = [["Fizz", -> n { n % 3 == 0 }],
+                              ['Buzz', -> n { n % 5 == 0 }]]
+
+def fizzbuzz_engine(range=FIZZBUZZ_DEFAULT_RANGE, factors=FIZZBUZZ_DEFAULT_FACTORS)
+  range.map do |n|
+    result = ""
+    factors.each do |(name, predicate)|
+      result << name if predicate.call(n)
+    end
+    result == "" ? n : result
+  end
+end
+
+def fizzbuzz
+  fizzbuzz_engine
+end
+end
 
 
 module Main     ## todo/check: use a class Runner instead (w/ include V1 etc.) - why? why not?

data/lib/fizzbuzzer/version.rb

@@ -3,8 +3,8 @@
 
 module FizzBuzzer
 
-  MAJOR = 0
-  MINOR = 1
+  MAJOR = 1
+  MINOR = 0
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 

data/test/helper.rb

@@ -0,0 +1,10 @@
+## $:.unshift(File.dirname(__FILE__))
+
+## minitest setup
+
+require 'minitest/autorun'
+
+
+## our own code
+
+require 'fizzbuzzer'

data/test/test_fizzbuzz.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_fizzbuzz.rb
+
+
+require 'helper'
+
+
+FIZZBUZZES_1_TO_100 =
+  [1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz", 11, "Fizz", 13, 14,
+  "FizzBuzz", 16, 17, "Fizz", 19, "Buzz", "Fizz", 22, 23, "Fizz", "Buzz", 26,
+  "Fizz", 28, 29, "FizzBuzz", 31, 32, "Fizz", 34, "Buzz", "Fizz", 37, 38,
+  "Fizz", "Buzz", 41, "Fizz", 43, 44, "FizzBuzz", 46, 47, "Fizz", 49, "Buzz",
+  "Fizz", 52, 53, "Fizz", "Buzz", 56, "Fizz", 58, 59, "FizzBuzz", 61, 62,
+  "Fizz", 64, "Buzz", "Fizz", 67, 68, "Fizz", "Buzz", 71, "Fizz", 73, 74,
+  "FizzBuzz", 76, 77, "Fizz", 79, "Buzz", "Fizz", 82, 83, "Fizz", "Buzz", 86,
+  "Fizz", 88, 89, "FizzBuzz", 91, 92, "Fizz", 94, "Buzz", "Fizz", 97, 98,
+  "Fizz", "Buzz"]
+
+## all strings version
+##   e.g. ["1", "2", "Fizz", ...]
+FIZZBUZZES_1_TO_100_V2 = FIZZBUZZES_1_TO_100.map {|value| value.to_s }
+
+
+class TestV1 < MiniTest::Test
+  include FizzBuzzer::V1
+
+def test_fizzbuzz
+   assert_equal FIZZBUZZES_1_TO_100, fizzbuzz
+end
+end # class TestV1
+
+
+## auto-generate test classes (see model/sample above)
+##   todo/fix: use a version without eval - possible? why? why not?
+
+%w[V2a V2b V2c V2d V3 V4 V5 V6a V6b V7 V8 V9 V10 V11 V12a V12b].each do |name|
+  eval %Q(
+    class Test#{name} < MiniTest::Test
+      include FizzBuzzer::#{name}
+
+      def test_fizzbuzz
+        puts "running fizzbuzz #{name}..."
+        if %w[V4 V11].include? '#{name}'
+          # use all string version e.g. ["1", "2", "Fizz", ...]
+          assert_equal FIZZBUZZES_1_TO_100_V2, fizzbuzz
+        else
+          # use "mixed" tuple version e.g. [1, 2, "Fizz", ...]
+          assert_equal FIZZBUZZES_1_TO_100, fizzbuzz
+        end
+      end
+    end)
+end

data/test/test_version.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_version.rb
+
+
+require 'helper'
+
+
+class TestVersion < MiniTest::Test
+
+def test_version
+   pp FizzBuzzer.version
+   pp FizzBuzzer.banner
+   pp FizzBuzzer.root
+
+   assert true  ## (for now) everything ok if we get here
+end
+
+end  # class TestVersion

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: fizzbuzzer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-22 00:00:00.000000000 Z
+date: 2018-01-23 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: noaidi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-matcher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -59,6 +87,9 @@ files:
 - bin/fizzbuzz
 - lib/fizzbuzzer.rb
 - lib/fizzbuzzer/version.rb
+- test/helper.rb
+- test/test_fizzbuzz.rb
+- test/test_version.rb
 homepage: https://github.com/rubylibs/fizzbuzzer
 licenses:
 - Public Domain