rushcheck 0.3 → 0.4

data/lib/rushcheck/gen.rb

@@ -4,223 +4,235 @@
 # Therefore check also the Haskell implementation.
 
 require 'rushcheck/gen'
+require 'rushcheck/integer'
 
-# Gen provides functions for generating test instances.
-class Gen
+module RushCheck
 
-  @@max_create = 10000
+  # Gen provides functions for generating test instances.
+  class Gen
 
-  # choose is one of primitive generators to create a random Gen object. 
-  # choose returns a Gen object which generates a random value in the
-  # bound. It may useful to implement arbitrary method into your class.
-  def self.choose(lo=nil, hi=nil)
-    rand.fmap {|x| lo.class.random(x, lo, hi)[0] }
-  end
+    @@max_create = 10000
 
-  # create is one of primitive generators to create a random Gen object.
-  # create takes an array of Gen objects, and any block to generate object.
-  # Then create returns a Gen object. It may useful to implement
-  # arbitrary method into your class.
-  def self.create(xs, &f)
-    Gen.new do |n, r|
-      r2 = r
-      nguard = f.arity - xs.length
-      guards = nguard >= 0 ? Array.new(nguard, Guard.new) : []
-
-      try = 0
-      begin
-        if try > @@max_create 
-          raise(RuntimeError, "Failed to guards too many.") 
-        end
-        args = xs.map do |gen|
-          r1, r2 = r2.split
-          gen.value(n, r1)
-        end
-        ys = args + guards
-        f.call(*ys)
-      rescue Exception => ex
-        case ex
-        when RushCheckGuard
-          try += 1
-          retry
-        else
-          raise(ex, ex.to_s)
+    # choose is one of primitive generators to create a random Gen object. 
+    # choose returns a Gen object which generates a random value in the
+    # bound. It may useful to implement arbitrary method into your class.
+    def self.choose(lo=nil, hi=nil)
+      rand.fmap {|x| lo.class.random(x, lo, hi)[0] }
+    end
+
+    # create_gen is one of primitive generators to create a random Gen object.
+    # create_gen takes an array of Gen objects, and any block to generate object.
+    # Then create_gen returns a Gen object. It may useful to implement
+    # arbitrary method into your class.
+    def self.create_by_gen(xs, &f)
+      raise ArgumentError unless f.arity == xs.length
+      self.new do |n, r|
+        r2 = r
+
+        try = 0
+        begin
+          if try > @@max_create 
+            raise(RuntimeError, "Failed to guards too many in the assertion.") 
+          end
+          args = xs.map do |gen|
+            r1, r2 = r2.split
+            gen.value(n, r1)
+          end
+          f.call(*args)
+        rescue Exception => ex
+          case ex
+          when RushCheck::GuardException
+            try += 1
+            retry
+          else
+            raise(ex, ex.to_s)
+          end
         end
       end
     end
-  end
 
-  # elements is one of primitive generators to create a random Gen
-  # object. elements requires an array and returns a Gen object which
-  # generates an object in the array randomly. It may useful to
-  # implement arbitrary method into your class. 
-  def self.elements(xs)
-    raise(RuntimeError, "given argument is empty") if xs.empty?
+    # create is one of primitive generators to create a random Gen object.
+    # create takes an array of classes, and any block to generate object.
+    # Then create returns a Gen object. It may useful to implement
+    # arbitrary method into your class.
+    def self.create(cs, &f)
+      self.create_by_gen(cs.map {|c| c.arbitrary}) { yield f }
+    end
 
-    choose(0, xs.length - 1).fmap {|i| xs[i] }
-  end
+    # elements is one of primitive generators to create a random Gen
+    # object. elements requires an array and returns a Gen object which
+    # generates an object in the array randomly. It may useful to
+    # implement arbitrary method into your class. 
+    def self.elements(xs)
+      raise(RuntimeError, "given argument is empty") if xs.empty?
 
-  # frequency is one of primitive generators to create a random Gen
-  # object. frequency requires an array of pairs and returns a Gen
-  # object. The first component of pair should be a positive Integer
-  # and the second one should be a Gen object. The integer acts as a
-  # weight for choosing random Gen object in the array. For example,
-  # frequency([[1, Gen.rand], [2, Integer.arbitrary]]) returns the
-  # random generator Gen.rand in 33%, while another random generator
-  # of Integer (Integer.arbitrary) in 67%.
-  def self.frequency(xs)
-    tot = xs.inject(0) {|r, pair| r + pair[0]}
-    raise(RuntimeError, "Illegal frequency:#{xs.inspect}") if tot == 0
-    choose(0, tot - 1).bind do |n|
-      m = n
-      xs.each do |pair|
-        if m <= pair[0]
-        then break pair[1]
-        else m -= pair[0]
+      choose(0, xs.length - 1).fmap {|i| xs[i] }
+    end
+
+    # frequency is one of primitive generators to create a random Gen
+    # object. frequency requires an array of pairs and returns a Gen
+    # object. The first component of pair should be a positive Integer
+    # and the second one should be a Gen object. The integer acts as a
+    # weight for choosing random Gen object in the array. For example,
+    # frequency([[1, Gen.rand], [2, Integer.arbitrary]]) returns the
+    # random generator Gen.rand in 33%, while another random generator
+    # of Integer (Integer.arbitrary) in 67%.
+    def self.frequency(xs)
+      tot = xs.inject(0) {|r, pair| r + pair[0]}
+      raise(RuntimeError, "Illegal frequency:#{xs.inspect}") if tot == 0
+      choose(0, tot - 1).bind do |n|
+        m = n
+        xs.each do |pair|
+          if m <= pair[0]
+          then break pair[1]
+          else m -= pair[0]
+          end
         end
-      end
-    end 
-  end
+      end 
+    end
 
-  # lift_array is one of primitive generators to create a randam Gen
-  # object. lift_array takes an array and a block which has a
-  # variable. The block should return a Gen object. lift_array returns
-  # a Gen object which generates an array of the result of given block
-  # for applying each member of given array. 
-  def self.lift_array(xs)
-    Gen.new do |n, r|
-      r2 = r
-      xs.map do |c|
-        r1, r2 = r2.split
-        yield.value(n, r1)
+    # lift_array is one of primitive generators to create a randam Gen
+    # object. lift_array takes an array and a block which has a
+    # variable. The block should return a Gen object. lift_array returns
+    # a Gen object which generates an array of the result of given block
+    # for applying each member of given array. 
+    def self.lift_array(xs)
+      self.new do |n, r|
+        r2 = r
+        xs.map do |c|
+          r1, r2 = r2.split
+          yield.value(n, r1)
+        end
       end
     end
-  end
 
-  # oneof is /one of/ primitive generators to create a random Gen object.
-  # oneof requires an array of Gen objects, and returns a Gen object
-  # which choose a Gen object in the array randomly.
-  # It may useful to implement arbitrary method into your class.
-  def self.oneof(gens)
-    elements(gens).bind {|x| x}
-  end
+    # oneof is /one of/ primitive generators to create a random Gen object.
+    # oneof requires an array of Gen objects, and returns a Gen object
+    # which choose a Gen object in the array randomly.
+    # It may useful to implement arbitrary method into your class.
+    def self.oneof(gens)
+      elements(gens).bind {|x| x}
+    end
 
-  # promote is the function to create a Gen object which generates a
-  # procedure (Proc). promote requires a block which takes one
-  # variable and the block should be return a Gen object.
-  # promote returns a Gen object which generate a new procedure
-  # with the given block.
-  # It may useful to implement coarbitrary method into your class.
-  def self.promote
-    new {|n, r| Proc.new {|a| yield(a).value(n, r) } }
-  end
+    # promote is the function to create a Gen object which generates a
+    # procedure (Proc). promote requires a block which takes one
+    # variable and the block should be return a Gen object.
+    # promote returns a Gen object which generate a new procedure
+    # with the given block.
+    # It may useful to implement coarbitrary method into your class.
+    def self.promote
+      new {|n, r| Proc.new {|a| yield(a).value(n, r) } }
+    end
 
-  # rand returns a Gen object which generates a random number
-  # generator. 
-  def self.rand
-    new {|n, r| r}
-  end
+    # rand returns a Gen object which generates a random number
+    # generator. 
+    def self.rand
+      new {|n, r| r}
+    end
 
-  # sized is a combinator which the programmer can use to access the
-  # size bound. It requires a block which takes a variable as an
-  # integer for size. The block should be a function which changes the
-  # size of random instances.
-  def self.sized
-    new {|n, r| yield(n).value(n, r) }
-  end
+    # sized is a combinator which the programmer can use to access the
+    # size bound. It requires a block which takes a variable as an
+    # integer for size. The block should be a function which changes the
+    # size of random instances.
+    def self.sized
+      new {|n, r| yield(n).value(n, r) }
+    end
 
-  # unit is a monadic function which equals the return function in
-  # the Haskell's monad. It requires one variable and returns a Gen
-  # object which generates the given object.
-  def self.unit(x)
-    new {|n, r| x}
-  end
+    # unit is a monadic function which equals the return function in
+    # the Haskell's monad. It requires one variable and returns a Gen
+    # object which generates the given object.
+    def self.unit(x)
+      new {|n, r| x}
+    end
 
-  # vector is one of primitive generators to create a Gen object.
-  # vector takes two variables, while the first one should be class,
-  # and the second one should be length. vector returns a Gen object
-  # which generates an array whose components belongs the given class
-  # and given length.
-  def self.vector(c, len)
-    new do |n, r|
-      r2 = r
-      (1..len).map do 
-        r1, r2 = r2.split
-        c.arbitrary.value(n, r1) 
+    # vector is one of primitive generators to create a Gen object.
+    # vector takes two variables, while the first one should be class,
+    # and the second one should be length. vector returns a Gen object
+    # which generates an array whose components belongs the given class
+    # and given length.
+    def self.vector(c, len)
+      new do |n, r|
+        r2 = r
+        (1..len).map do 
+          r1, r2 = r2.split
+          c.arbitrary.value(n, r1) 
+        end
       end
     end
-  end
 
-  # to initialize Gen object, it requires a block which takes two
-  # variables. The first argument of block is assumed as an integer,
-  # and the second one is assumed as a random generator of RandomGen.
-  def initialize(&f)
-    @proc = f    
-  end
+    # to initialize Gen object, it requires a block which takes two
+    # variables. The first argument of block is assumed as an integer,
+    # and the second one is assumed as a random generator of RandomGen.
+    def initialize(&f)
+      @proc = f    
+    end
 
-  # bind is a monadic function such as Haskel's (>>=).
-  # bind takes a block which has two variables where the first one
-  # is assumed as an integer, and the second one is assumed as a
-  # random generator of RandomGen.
-  def bind
-    self.class.new do |n, r| 
-      r1, r2 = r.split
-      yield(value(n, r1)).value(n, r2)
+    # bind is a monadic function such as Haskel's (>>=).
+    # bind takes a block which has two variables where the first one
+    # is assumed as an integer, and the second one is assumed as a
+    # random generator of RandomGen.
+    def bind
+      self.class.new do |n, r| 
+        r1, r2 = r.split
+        yield(value(n, r1)).value(n, r2)
+      end
     end
-  end
 
-  # value is a method to get the value of the internal procedure.
-  # value takes two variables where the first argument is assumed as
-  # an integer and the second one is assumed as a random generator of
-  # RandomGen. 
-  def value(n, g)
-    @proc.call(n, g)
-  end
+    # value is a method to get the value of the internal procedure.
+    # value takes two variables where the first argument is assumed as
+    # an integer and the second one is assumed as a random generator of
+    # RandomGen. 
+    def value(n, g)
+      @proc.call(n, g)
+    end
 
-  # fmap is a categorical function as same in Haskell.
-  # fmap requires a block which takes one variable.
-  def fmap
-    bind {|x| Gen.unit(yield(x)) }
-  end
+    # fmap is a categorical function as same in Haskell.
+    # fmap requires a block which takes one variable.
+    def fmap
+      bind {|x| self.class.unit(yield(x)) }
+    end
 
-  # forall is a function to create a Gen object.
-  # forall requires a block which takes any variables
-  # and returns a Property object. Then forall returns
-  # a generator of the property.
-  def forall
-    bind do |*a|
-      yield(*a).property.bind do |res|
-        res.arguments.push(a.to_s)
-        Gen.unit(res)
+    # forall is a function to create a Gen object.
+    # forall requires a block which takes any variables
+    # and returns a Property object. Then forall returns
+    # a generator of the property.
+    def forall
+      bind do |*a|
+        yield(*a).property.bind do |res|
+          res.arguments.push(a.to_s)
+          self.class.unit(res)
+        end
       end
     end
-  end
 
-  # generate returns the random instance. generates takes two
-  # variables, where the first one should be an integer and the second
-  # should be the random number generator such as StdGen.
-  def generate(n, rnd)
-    s, r = Integer.random(rnd, 0, n)
-    value(s, r)
-  end
+    # generate returns the random instance. generates takes two
+    # variables, where the first one should be an integer and the second
+    # should be the random number generator such as StdGen.
+    def generate(n, rnd)
+      s, r = Integer.random(rnd, 0, n)
+      value(s, r)
+    end
 
-  # resize returns another Gen object which resized by the given
-  # paramater. resize takes one variable in Integer.
-  def resize(n)
-    self.class.new {|x, r| value(n, r) }
-  end
+    # resize returns another Gen object which resized by the given
+    # paramater. resize takes one variable in Integer.
+    def resize(n)
+      self.class.new {|x, r| value(n, r) }
+    end
 
-  # variant constructs a generator which transforms the random number
-  # seed. variant takes one variable which should be an
-  # Integer. variant is needed to generate rundom functions.
-  def variant(v)
-    self.class.new do |n, r| 
-      g = (1..v).inject(r) do |gen, i| 
-        gen, dummy = gen.split 
-        gen
+    # variant constructs a generator which transforms the random number
+    # seed. variant takes one variable which should be an
+    # Integer. variant is needed to generate rundom functions.
+    def variant(v)
+      self.class.new do |n, r| 
+        g = (1..v).inject(r) do |gen, i| 
+          gen, dummy = gen.split 
+          gen
+        end
+        value(n, g)
       end
-      value(n, g)
     end
+
   end
 
 end
+

data/lib/rushcheck/guard.rb

@@ -1,11 +1,13 @@
 # = guard.rb
-# This provides class Guard
+# This provides module functions guard and its friends
 
-class RushCheckGuard < StandardError; end
+module RushCheck
 
-# class Guard is used for RushCheck internally and many user
-# don't care about this class.
-class Guard
+  class GuardException < StandardError; end
+
+  def guard
+    raise RushCheck::GuardException unless yield
+  end
 
   def guard_raise(c)
     begin
@@ -13,15 +15,12 @@ class Guard
     rescue Exception => ex
       case ex
       when c
-        raise RushCheckGuard
+        raise RushCheck::GuardException
       else
         raise ex
       end
     end
   end
-
-  def guard
-    raise RushCheckGuard unless yield
-  end
+  module_function :guard, :guard_raise
 
 end

data/lib/rushcheck/hash.rb

@@ -9,8 +9,8 @@ require 'rushcheck/testable'
 # defined random generator of Hash.
 class RandomHash < Hash
 
-  extend Arbitrary
-  include Coarbitrary
+  extend RushCheck::Arbitrary
+  include RushCheck::Coarbitrary
 
   # class method set_pattern takes a hash object of
   # random pattern. For example, the following pattern
@@ -20,10 +20,11 @@ class RandomHash < Hash
   # has indicated random object as its values.
   def self.set_pattern(pat)
     @@pat = pat
+    self
   end
   
   def self.arbitrary
-    Gen.new do |n, r|
+    RushCheck::Gen.new do |n, r|
       h = {}
       r2 = r
       @@pat.keys.each do |k|

data/lib/rushcheck/integer.rb

@@ -9,9 +9,10 @@ require 'rushcheck/random'
 # ruby's Integer class is extended to use RushCheck library.
 # See also HsRandom, Arbitrary and Coarbitrary.
 class Integer
-  extend HsRandom
-  extend Arbitrary
-  include Coarbitrary
+  extend RushCheck::HsRandom
+  extend RushCheck::Arbitrary
+
+  include RushCheck::Coarbitrary
 
   @@max_bound =  2**30 - 1
   @@min_bound = -(2**30)
@@ -23,15 +24,19 @@ class Integer
 
   # this method is needed to use Arbitrary.
   def self.arbitrary
-    Gen.sized {|n| Gen.choose(-n, n) }
+    RushCheck::Gen.sized {|n| RushCheck::Gen.choose(-n, n) }
   end
 
   # this method is needed to include HsRandom.
   def self.random_range(gen, lo=@@min_bound, hi=@@max_bound)
-    raise(RuntimeError, "illegal arguments:#{lo}, #{hi}") if hi - lo + 1 == 0
+    hi, lo = lo, hi if hi < lo 
     v, g = gen.gen_next
+    d = hi - lo + 1
 
-    [(v % (hi - lo + 1)) + lo, g]
+    if d == 1
+    then [lo, g]
+    else [(v % d) + lo, g]
+    end
   end
 
   # this method is needed to use Coarbitrary.

data/lib/rushcheck/proc.rb

@@ -8,16 +8,16 @@ require 'rushcheck/testable'
 
 class RandomProc < Proc
 
-  extend Arbitrary
-  include Coarbitrary
-  include Testable
+  extend RushCheck::Arbitrary
+  include RushCheck::Coarbitrary
+  include RushCheck::Testable
 
   def self.set_pattern(inputs, outputs)
     @@inputs, @@outputs = inputs, outputs
   end
 
   def self.arbitrary
-    Gen.new do |n, r|
+    RushCheck::Gen.new do |n, r|
       Proc.new do |*args|
         gens = if args.empty?
                then @@outputs.map {|c| c.arbitrary }
@@ -27,13 +27,13 @@ class RandomProc < Proc
                       end
                     end.flatten
                end
-        Gen.oneof(gens).value(n, r)
+        RushCheck::Gen.oneof(gens).value(n, r)
       end
     end
   end
 
   def coarbitrary(g)
-    Gen.new do |n, r|
+    RushCheck::Gen.new do |n, r|
       r2 = r
       args = @@inputs.map do |c| 
         r1, r2 = r2.split
@@ -45,7 +45,7 @@ class RandomProc < Proc
   end
 
   def property
-    Gen.lift_array(@@inputs) {|c| c.arbitrary }.forall do |*args|
+    RushCheck::Gen.lift_array(@@inputs) {|c| c.arbitrary }.forall do |*args|
       call(*args)
     end
   end

data/lib/rushcheck/property.rb

@@ -5,25 +5,29 @@ require 'rushcheck/gen'
 require 'rushcheck/result'
 require 'rushcheck/testable'
 
-class Property
+module RushCheck
 
-  include Testable
+  class Property
 
-  attr_reader :gen
-  def initialize(obj=nil, stamp=[], arguments=[])
-    case obj
-    when nil, true, false
-      result = Result.new(obj, stamp, arguments)
-      @gen    = Gen.unit(result)
-    when Gen
-      @gen = obj
-    else
-      raise(RuntimeError, "illegal arguments")
+    include RushCheck::Testable
+
+    attr_reader :gen
+    def initialize(obj=nil, stamp=[], arguments=[])
+      case obj
+      when nil, true, false
+        result = RushCheck::Result.new(obj, stamp, arguments)
+        @gen    = RushCheck::Gen.unit(result)
+      when Gen
+        @gen = obj
+      else
+        raise(RuntimeError, "illegal arguments")
+      end
+    end
+
+    def property
+      self
     end
-  end
 
-  def property
-    self
   end
 
 end