ruby-fizzbuzz 0.7.0 → 0.8.0

data/ext/fizzbuzz/fizzbuzz.h

@@ -1,23 +1,3 @@
-/* :enddoc: */
-
-/*
- * fizzbuzz.h
- *
- * Copyright 2012-2014 Krzysztof Wilczynski
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 #if !defined(_FIZZBUZZ_H)
 #define _FIZZBUZZ_H 1
 
@@ -36,14 +16,15 @@ extern "C" {
 #define MINUS(a, b) fizzbuzz_minus((a), (b))
 #define MOD(a, b)   fizzbuzz_modulo((a), (b))
 
-#define GREATER(a, b)       fizzbuzz_greater((a), (b))
+#define GREATER(a, b)	    fizzbuzz_greater((a), (b))
 #define GREATER_EQUAL(a, b) fizzbuzz_greater_equal((a), (b))
 #define LESS_EQUAL(a, b)    fizzbuzz_less_equal((a), (b))
 
-#define INTEGER_P(x) (TYPE(x) == T_FIXNUM || TYPE(x) == T_BIGNUM)
+#define INTEGER_P(x) \
+	(RB_TYPE_P((x), T_FIXNUM) || RB_TYPE_P((x), T_BIGNUM))
 
 #define ZERO_P(x) \
-    (FIXNUM_P(x) ? (NUM2TYPE(x) == 0) : fizzbuzz_equal((x), ZERO))
+	(FIXNUM_P(x) ? (NUM2TYPE(x) == 0) : fizzbuzz_equal((x), ZERO))
 
 #define INCREASE(x) PLUS((x),  ONE)
 #define DECREASE(x) MINUS((x), ONE)
@@ -51,11 +32,11 @@ extern "C" {
 #define COMPUTE_MOD_3(x) ZERO_P(MOD((x), THREE))
 #define COMPUTE_MOD_5(x) ZERO_P(MOD((x), FIVE))
 
-#define SCORE_FIXNUM(x) (uint8_t)(!((x) % 3) + 2 * !((x) % 5))
-#define SCORE_BIGNUM(x) (uint8_t)(COMPUTE_MOD_3(x) + 2 * COMPUTE_MOD_5(x))
+#define SCORE_FIXNUM(x) (int)(!((x) % 3) + 2 * !((x) % 5))
+#define SCORE_BIGNUM(x) (int)(COMPUTE_MOD_3(x) + 2 * COMPUTE_MOD_5(x))
 
 #define SCORE_VALUE(x) \
-    (FIXNUM_P(x) ? SCORE_FIXNUM(NUM2TYPE(x)) : SCORE_BIGNUM(x))
+	(FIXNUM_P(x) ? SCORE_FIXNUM(NUM2TYPE(x)) : SCORE_BIGNUM(x))
 
 #define IS_FIZZ(x)     (!ZERO_P(x) && (SCORE_VALUE(x) == 1))
 #define IS_BUZZ(x)     (!ZERO_P(x) && (SCORE_VALUE(x) == 2))
@@ -66,157 +47,120 @@ extern "C" {
 #define LOOP_FORWARD(x) ((x) == D_LOOP_FORWARD)
 #define LOOP_REVERSE(x) ((x) == D_LOOP_REVERSE)
 
-#define CHECK_TYPE(x, m)                                                    \
-    do {                                                                    \
-        if (!INTEGER_P(x)) {                                                \
-            VALUE __e_type = fizzbuzz_type_error(rb_fb_eTypeError, (m));    \
-            rb_exc_raise(__e_type);                                         \
-        }                                                                   \
+#define CHECK_TYPE(x, m)						\
+    do {								\
+	if (!INTEGER_P(x))						\
+	    rb_exc_raise(fizzbuzz_type_error(rb_fb_eTypeError, (m)));	\
     } while (0)
 
-#define CHECK_RANGE(x, y, m)                                                            \
-    do {                                                                                \
-        if (GREATER(x, y)) {                                                            \
-            VALUE __e_range = fizzbuzz_range_error(rb_fb_eRangeError, (x), (y), (m));   \
-            rb_exc_raise(__e_range);                                                    \
-        }                                                                               \
+#define CHECK_RANGE(x, y, m)							    \
+    do {									    \
+	if (GREATER(x, y))							    \
+	    rb_exc_raise(fizzbuzz_range_error(rb_fb_eRangeError, (x), (y), (m)));   \
     } while (0)
 
 #define error(t) errors[(t)]
 #define word(n)  words[(n) - 1]
 
-enum fizzbuzz_error {
+typedef enum fizzbuzz_error {
     E_INVALID_TYPE = 0,
     E_INVALID_START_TYPE,
     E_INVALID_STOP_TYPE,
     E_BAD_VALUE_START,
     E_BAD_VALUE_STOP
-};
+} fizzbuzz_error_t;
 
-enum fizzbuzz_return {
+typedef enum fizzbuzz_return {
     R_TYPE_ARRAY = 0,
     R_TYPE_ENUMERATOR
-};
+} fizzbuzz_return_t;
 
-enum fizzbuzz_direction {
+typedef enum fizzbuzz_direction {
     D_LOOP_FORWARD = 0,
     D_LOOP_REVERSE
-};
-
-typedef enum fizzbuzz_return fizzbuzz_return_t;
-typedef enum fizzbuzz_direction fizzbuzz_direction_t;
+} fizzbuzz_direction_t;
 
-struct fizzbuzz_exception {
+typedef struct fizzbuzz_exception {
     VALUE start;
     VALUE stop;
     const char *message;
     VALUE klass;
-};
-
-typedef struct fizzbuzz_exception fizzbuzz_exception_t;
+} fizzbuzz_exception_t;
 
 static const char *errors[] = {
+#if defined(HAVE_INTEGER_UNIFICATION)
+    "must be an Integer type",
+    "must be an Integer type for start",
+    "must be an Integer type for stop",
+#else
     "must be a Fixnum or Bignum type",
     "must be a Fixnum or Bignum type for start",
     "must be a Fixnum or Bignum type for stop",
+#endif
     "start value is higher than stop value",
     "stop value is lower than start value",
     NULL
 };
 
-static const char *words[] = {
-    "Fizz", "Buzz",
-    "FizzBuzz", NULL
+static VALUE words[] = {
+    Qnil, Qnil, Qnil,
+    Qundef
 };
 
-inline static VALUE
+static VALUE
 fizzbuzz_plus(VALUE a, VALUE b)
 {
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-        return TYPE2NUM(NUM2TYPE(a) + NUM2TYPE(b));
-    }
-
-    return rb_funcall(a, rb_intern("+"), 1, b);
+    return (FIXNUM_P(a) && FIXNUM_P(b)) ?	 \
+	   TYPE2NUM(NUM2TYPE(a) + NUM2TYPE(b)) : \
+	   rb_funcall(a, rb_intern("+"), 1, b);
 }
 
-inline static VALUE
+static VALUE
 fizzbuzz_minus(VALUE a, VALUE b)
 {
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-        return TYPE2NUM(NUM2TYPE(a) - NUM2TYPE(b));
-    }
-
-    return rb_funcall(a, rb_intern("-"), 1, b);
+    return (FIXNUM_P(a) && FIXNUM_P(b)) ?	 \
+	   TYPE2NUM(NUM2TYPE(a) - NUM2TYPE(b)) : \
+	   rb_funcall(a, rb_intern("-"), 1, b);
 }
 
-inline static VALUE
+static VALUE
 fizzbuzz_modulo(VALUE a, VALUE b)
 {
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-        return TYPE2NUM(NUM2TYPE(a) % NUM2TYPE(b));
-    }
-
-    return rb_funcall(a, rb_intern("%"), 1, b);
+    return (FIXNUM_P(a) && FIXNUM_P(b)) ?	 \
+	   TYPE2NUM(NUM2TYPE(a) % NUM2TYPE(b)) : \
+	   rb_funcall(a, rb_intern("%"), 1, b);
 }
 
-inline static VALUE
+static int
 fizzbuzz_equal(VALUE a, VALUE b)
 {
-    VALUE result;
-
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-        result = (NUM2TYPE(a) == NUM2TYPE(b));
-    }
-    else {
-        result = rb_funcall(a, rb_intern("=="), 1, b);
-    }
-
-    return RVAL2CBOOL(result);
+    return RB_LIKELY(FIXNUM_P(a) && FIXNUM_P(b)) ?  \
+	   (NUM2TYPE(a) == NUM2TYPE(b)) :	    \
+	   RVAL2CBOOL(rb_funcall(a, rb_intern("=="), 1, b));
 }
 
-inline static VALUE
+static int
 fizzbuzz_greater(VALUE a, VALUE b)
 {
-    VALUE result;
-
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-        result = (NUM2TYPE(a) > NUM2TYPE(b));
-    }
-    else {
-        result = rb_funcall(a, rb_intern(">"), 1, b);
-    }
-
-    return RVAL2CBOOL(result);
+    return RB_LIKELY(FIXNUM_P(a) && FIXNUM_P(b)) ?  \
+	   (NUM2TYPE(a) > NUM2TYPE(b)) :	    \
+	   RVAL2CBOOL(rb_funcall(a, rb_intern(">"), 1, b));
 }
 
-inline static VALUE
+static int
 fizzbuzz_greater_equal(VALUE a, VALUE b)
 {
-    VALUE result;
-
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-        result = (NUM2TYPE(a) >= NUM2TYPE(b));
-    }
-    else {
-        result = rb_funcall(a, rb_intern(">="), 1, b);
-    }
-
-    return RVAL2CBOOL(result);
+    return RB_LIKELY(FIXNUM_P(a) && FIXNUM_P(b)) ?  \
+	   (NUM2TYPE(a) >= NUM2TYPE(b)) :	    \
+	   RVAL2CBOOL(rb_funcall(a, rb_intern(">="), 1, b));
 }
 
-inline static VALUE
+static int
 fizzbuzz_less_equal(VALUE a, VALUE b)
 {
-    VALUE result;
-
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-        result = (NUM2TYPE(a) <= NUM2TYPE(b));
-    }
-    else {
-        result = rb_funcall(a, rb_intern("<="), 1, b);
-    }
-
-    return RVAL2CBOOL(result);
+    return RB_LIKELY(FIXNUM_P(a) && FIXNUM_P(b)) ?  \
+	   (NUM2TYPE(a) <= NUM2TYPE(b)) :	    \
+	   RVAL2CBOOL(rb_funcall(a, rb_intern("<="), 1, b));
 }
 
 RUBY_EXTERN ID id_at_start, id_at_stop;
@@ -249,5 +193,3 @@ RUBY_EXTERN VALUE rb_fb_square(VALUE object, VALUE value);
 #endif
 
 #endif /* _FIZZBUZZ_H */
-
-/* vim: set ts=8 sw=4 sts=2 et : */

data/kwilczynski-public.pem

@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEIDCCAoigAwIBAgIBATANBgkqhkiG9w0BAQsFADAdMRswGQYDVQQDDBJrdy9E
+Qz1saW51eC9EQz1jb20wHhcNMTkwODAzMTUzOTEzWhcNMjAwODAyMTUzOTEzWjAd
+MRswGQYDVQQDDBJrdy9EQz1saW51eC9EQz1jb20wggGiMA0GCSqGSIb3DQEBAQUA
+A4IBjwAwggGKAoIBgQCroSgHc4BNx1gFHRHBbLvyKbsQPoa8uZVUbQ4uXuI9URdR
+Uho84FcXnFOLjWaTHXX6aG9OI08zWSwV0mcg19PZakjqbdUw8WAGvBnpkwFNz/gG
+J46+T+BDQ0gLWuoMLYEAOjUcRqcaMUgsspUXpKCbbtBId782yieyKsCWDgBxtUZd
+5jPgrAEpOW8C1p8K+MlNXjBvib/K5ODk28BqGcKGa0udRJ9yfD/k4MczUcRGgaNg
+Pno2ncH8Jw/Dcfy4gZgHKsTGCtqOQbsKc5G5u0hDgIGJ6FVvR620TUPGvpFUG1A/
+otGkdoe6MDLciUbJmYIr6I3ykNF+IWmPmZCHsOKd9a7neVk+TGJQYiKo74XG9cbo
+Ms8HQomJTNWMM0csu0fWq/jB0T2Lbg9N1gjJ4neR82CwE1galmWCNguD7EVO+axn
+nFrxCnT9Lc1YvyJMfx1Rr+guC/S2LMY/GgSwxiSwt7eh+AGv5tfgNdHuFyFHNFrz
+pAdaz5CqFRalQkZ169ECAwEAAaNrMGkwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+HQYDVR0OBBYEFPa4Bg07AC8HR7uy6WCYWXP8wLGwMBcGA1UdEQQQMA6BDGt3QGxp
+bnV4LmNvbTAXBgNVHRIEEDAOgQxrd0BsaW51eC5jb20wDQYJKoZIhvcNAQELBQAD
+ggGBAEBJuRhodAsjx52dYS/9tKTCbXOoGH1qYYiGHWVXCt2ZJYXB34bTWjqpT7w9
+dw/I0HydvKk8kYs3LWDDmg6hDIPJ5Br4+sadBD1r5dBhpY3WNkMHoTziOTiNr+Pw
+GqF0vWVmZ704XX2S2jzu05EWefDQ+wnMzfevx8hEGIvg2P/d7z3wxce2TvsrpBBY
+iocpBLUiK0EVHBf1BvgC/V01i9xGNg7KdN2dVfLoLSyvrB5MV3ITxiKgrIU0xi6v
+J1KaY5b2N5ZnZaN8cTs5Z0skUkUqPQPFxQL5SM9LyK5gVT2qcF8QhChst8RCUXz9
+3DdMAGkSExtG/qLRnpPwBszjGZqASIi/OJ9QsAESmMExgwqH1bYAoGNQ60V7iiI0
+Vygrj8cyzqtclWVwszcoLCcEPQW0S4sXmIuvIQ9Uc6UuKM4mHkNTMvSjNSShdAkA
+7/RnMCIYLU7PievOwRMbF7/22H+PSuMW6/JqGRYk8pph//oNh1EoNFqu7h+bV0Ph
+Y0aXRQ==
+-----END CERTIFICATE-----

data/lib/fizzbuzz.rb

@@ -1,35 +1,15 @@
-# -*- encoding: utf-8 -*-
-
-# :stopdoc:
-
-#
-# fizzbuzz.rb
-#
-# Copyright 2012-2014 Krzysztof Wilczynski
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# :startdoc:
-
-gem 'json', '>= 1.8.1'
+# frozen_string_literal: true
 
 require 'json'
 
 require_relative 'fizzbuzz/fizzbuzz'
 require_relative 'fizzbuzz/version'
 require_relative 'fizzbuzz/core/integer'
-require_relative 'fizzbuzz/core/bignum'
+
+unless 0.class == Integer
+  require_relative 'fizzbuzz/core/bignum'
+end
+
 require_relative 'fizzbuzz/core/array'
 require_relative 'fizzbuzz/core/range'
 
@@ -54,8 +34,8 @@ class FizzBuzz
   #
   # Example:
   #
-  #    FizzBuzz.fizzbuzz(1, 15)         #=> [1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz", 11, "Fizz", 13, 14, "FizzBuzz"]
-  #    FizzBuzz.fizzbuzz(1, 15, true)   #=> ["FizzBuzz", 14, 13, "Fizz", 11, "Buzz", "Fizz", 8, 7, "Fizz", "Buzz", 4, "Fizz", 2, 1]
+  #    FizzBuzz.fizzbuzz(1, 15)          #=> [1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz", 11, "Fizz", 13, 14, "FizzBuzz"]
+  #    FizzBuzz.fizzbuzz(1, 15, true)    #=> ["FizzBuzz", 14, 13, "Fizz", 11, "Buzz", "Fizz", 8, 7, "Fizz", "Buzz", 4, "Fizz", 2, 1]
   #
   # Example:
   #
@@ -92,6 +72,97 @@ class FizzBuzz
     end
   end
 
+  #
+  # call-seq:
+  #    FizzBuzz.step( start, stop, step ) {|value| block } -> an integer
+  #    FizzBuzz.step( start, stop, step )                  -> an Enumerator
+  #
+  # Calls the block _once_ for each subsequent value for a given range
+  # from +start+ to +stop+, passing the value as a parameter to the block
+  # in the increments of +step+.
+  #
+  # If no block is given, an +Enumerator+ is returned instead.
+  #
+  # Example:
+  #
+  #    s = FizzBuzz.step    #=> #<Enumerator: #<Enumerator::Generator:0x559db8e7>:each>
+  #    s.take(15).each {|value| puts "Got #{value}" }
+  #
+  # Produces:
+  #
+  #    Got 1
+  #    Got 2
+  #    Got Fizz
+  #    Got 4
+  #    Got Buzz
+  #    Got Fizz
+  #    Got 7
+  #    Got 8
+  #    Got Fizz
+  #    Got Buzz
+  #    Got 11
+  #    Got Fizz
+  #    Got 13
+  #    Got 14
+  #    Got FizzBuzz
+  #
+  # See also: FizzBuzz::fizzbuzz, FizzBuzz::[] and FizzBuzz#step
+  #
+  def self.step(start = 1, stop = nil, step = 1, &block)
+    if block_given?
+      start.step(stop, step) do |n|
+        yield FB[n]
+      end
+    else
+      Enumerator.new do |y|
+        start.step(stop, step).each do |n|
+          y << FB[n]
+        end
+      end
+    end
+  end
+
+  #
+  # call-seq:
+  #    fizzbuzz.step( start, stop, step ) {|value| block } -> an integer
+  #    fizzbuzz.step( start, stop, step )                  -> an Enumerator
+  #
+  # Calls the block _once_ for each subsequent value for a given range
+  # from +start+ to +stop+, passing the value as a parameter to the block
+  # in the increments of +step+.
+  #
+  # If no block is given, an +Enumerator+ is returned instead.
+  #
+  # Example:
+  #
+  #    fb = FizzBuzz.new(1, 15)    #=> #<FizzBuzz:0x5653a2d1 @start=1, @stop=15>
+  #    s = fb.step                 #=> #<Enumerator: #<Enumerator::Generator:0x559db8e7>:each>
+  #    s.take(15).each {|value| puts "Got #{value}" }
+  #
+  # Produces:
+  #
+  #    Got 1
+  #    Got 2
+  #    Got Fizz
+  #    Got 4
+  #    Got Buzz
+  #    Got Fizz
+  #    Got 7
+  #    Got 8
+  #    Got Fizz
+  #    Got Buzz
+  #    Got 11
+  #    Got Fizz
+  #    Got 13
+  #    Got 14
+  #    Got FizzBuzz
+  #
+  # See also: FizzBuzz::step, FizzBuzz::fizzbuzz and FizzBuzz::[]
+  #
+  def step(start = @start, stop = @stop, step = 1, &block)
+    self.class.step(start, stop, step, &block)
+  end
+
   #
   # call-seq:
   #    fizzbuzz.to_hash -> hash
@@ -100,7 +171,7 @@ class FizzBuzz
   #
   # Example:
   #
-  #    fb = FizzBuzz.new(1, 15)   #=> #<FizzBuzz:0x007fbe84 @start=1, @stop=15>
+  #    fb = FizzBuzz.new(1, 15)    #=> #<FizzBuzz:0x007fbe84 @start=1, @stop=15>
   #    fb.to_hash
   #
   # Produces:
@@ -125,14 +196,14 @@ class FizzBuzz
 
   #
   # call-seq:
-  #    fizzbuzz.as_json -> hash
+  #    fizzbuzz.as_json( arguments ) -> hash
   #
   # Returns a +hash+ representing the _FizzBuzz_ object that will be
   # used when generating a _JSON_ string representation.
   #
   # Example:
   #
-  #    fb = FizzBuzz.new(1, 15)   #=> #<FizzBuzz:0x007f90c1 @start=1, @stop=15>
+  #    fb = FizzBuzz.new(1, 15)    #=> #<FizzBuzz:0x007f90c1 @start=1, @stop=15>
   #    fb.as_json
   #
   # Produces:
@@ -147,19 +218,19 @@ class FizzBuzz
   #
   # See also: FizzBuzz#to_json and FizzBuzz#to_hash
   #
-  def as_json(*arguments)
+  def as_json(*)
     { JSON.create_id => self.class.name }.merge(to_hash)
   end
 
   #
   # call-seq:
-  #    fizzbuzz.to_json -> string
+  #    fizzbuzz.to_json( arguments ) -> string
   #
   # Returns a _JSON_ string representing the _FizzBuzz_ object.
   #
   # Example:
   #
-  #    fb = FizzBuzz.new(1, 15)   #=> #<FizzBuzz:0x007fce83 @start=1, @stop=15>
+  #    fb = FizzBuzz.new(1, 15)    #=> #<FizzBuzz:0x007fce83 @start=1, @stop=15>
   #    fb.to_json
   #
   # Produces:
@@ -198,7 +269,7 @@ class FizzBuzz
   #      }
   #    EOS
   #
-  #    fb = JSON.load(json)   #=> #<FizzBuzz:0x007fc082 @start=1, @stop=15>
+  #    fb = JSON.load(json)    #=> #<FizzBuzz:0x007fc082 @start=1, @stop=15>
   #    fb.to_hash
   #
   # Produces:
@@ -219,9 +290,4 @@ class FizzBuzz
   alias_method :to_h, :to_hash
 end
 
-# :enddoc:
-
 FB = FizzBuzz
-
-# vim: set ts=2 sw=2 sts=2 et :
-# encoding: utf-8