rdl 1.0.0.rc3 → 1.0.0.rc4

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test
+
+task :skel, [:cname,:prettyname] do |skel, varhash|
+  kls = eval "#{varhash[:cname]}.new"
+  mthds = kls.public_methods(false) + kls.private_methods(false) + kls.protected_methods(false)
+  mname = "types/ruby-2.2.3/#{varhash[:prettyname]}.rb"
+  touch mname
+  mthds.sort.each{ |m|
+    sh "echo \"  type '#{m}', '() -> '\" >> #{mname}"
+  }
+  sh "echo \"end\" >> #{mname}"
+end
+
+task :stat, [:fname,:outpath] do |stat,varhash|
+  ruby "extras/rdlstat.rb #{varhash[:fname]} #{varhash[:outpath]}"
+end
+
+task :statrun, [:fname] do |statrun,varhash|
+  ruby "#{varhash[:fname]}"
+end

data/gemfiles/Gemfile.travis

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'minitest'
+gem 'require_all'

data/lib/rdl/wrap.rb

@@ -401,7 +401,7 @@ class Object
     }
   end
 
-  def nowrap
+  def rdl_nowrap
     $__rdl_contract_switch.off {
       RDL.config { |config| config.add_nowrap(self, self.singleton_class) }
     }

data/lib/rdl_types.rb

@@ -1,2 +1,4 @@
-require_rel "../types/ruby-#{RUBY_VERSION}/_aliases.rb" # load type aliases first
-require_rel "../types/ruby-#{RUBY_VERSION}/*.rb"
+dir = RUBY_VERSION.split('.')[0] + ".x"
+
+require_rel "../types/ruby-#{dir}/_aliases.rb" # load type aliases first
+require_rel "../types/ruby-#{dir}/*.rb"

data/rdl.gemspec

@@ -0,0 +1,23 @@
+# In the top directory
+# gem build rdl.gemspec
+# gem install rdl-1.0.0.beta.1.gem
+
+Gem::Specification.new do |s|
+  s.name        = 'rdl'
+  s.version     = '1.0.0.rc4'
+  s.date        = '2015-12-17'
+  s.summary     = 'Ruby type and contract system'
+  s.description = <<-EOF
+RDL is a gem that allows contracts (pre- and postconditions) to be added to methods.
+Preconditions are checked at run time when the method is called, and
+postconditions are checked at run time when the method returns.
+RDL also includes extensive support for type contracts, which check the types of arguments and returns
+when the method is called and when it returns, respectively.
+EOF
+  s.authors     = ['Jeffrey S. Foster', 'Brianna M. Ren', 'T. Stephen Strickland', 'Alexander T. Yu']
+  s.email       = ['rdl-users@googlegroups.com']
+  s.files       = `git ls-files`.split($/)
+  s.homepage    = 'https://github.com/plum-umd/rdl'
+  s.license     = 'BSD-3-Clause'
+  s.add_runtime_dependency 'require_all', '~> 1.3', '>= 1.3.3'
+end

data/test/disabled_test_coverage.rb

@@ -0,0 +1,156 @@
+require 'set'
+require 'abbrev'
+require 'base64'
+require 'benchmark'
+require 'bigdecimal'
+require 'bigdecimal/math'
+require 'coverage.so'
+
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+require_relative '../lib/rdl_types.rb'
+
+RDL::Config.instance.profile_stats
+
+class Dummy
+  def self.each
+  end
+  def each
+  end
+end
+
+class TestStdlibTypes < Minitest::Test
+
+  def test_abbrev
+    assert_raises(RDL::Type::TypeError) { s0 = Abbrev.abbrev 5}
+    # From the Ruby stdlib documentation
+    s1 = Abbrev.abbrev(['ruby']) # -> {"ruby"=>"ruby", "rub"=>"ruby", "ru"=>"ruby", "r"=>"ruby"}
+    ev = {"ruby"=>"ruby", "rub"=>"ruby", "ru"=>"ruby", "r"=>"ruby"}
+    assert_equal(s1,ev)
+    # Other tests
+    assert_raises(RDL::Type::TypeError) { s2 = Abbrev.abbrev Dummy.new }
+  end
+
+  def test_base64
+    # From the Ruby stdlib documentation
+    e0 = Base64.encode64('Send reinforcements') # -> "U2VuZCByZWluZm9yY2VtZW50cw==\n"
+    d0 = Base64.decode64(e0) # -> "Send reinforcements"
+    #assert_equal(e0,d0)
+    e1 = Base64.strict_encode64('Send reinforcements')
+    d1 = Base64.strict_decode64(e1)
+    #assert_equal(e1,d1)
+    e2 = Base64.urlsafe_encode64('Send reinforcements')
+    d2 = Base64.urlsafe_decode64(e2)
+    #assert_equal(e2,d2)
+  end
+
+  def test_benchmark
+    skip "Skip these because they print to stdout"
+    # From the Ruby stdlib documentation
+    Benchmark.measure { "a"*1_000_000_000 }
+    n = 5000000
+    Benchmark.bm do |x|
+      x.report { for i in 1..n; a = "1"; end }
+      x.report { n.times do   ; a = "1"; end }
+      x.report { 1.upto(n) do ; a = "1"; end }
+    end
+    Benchmark.bm(7) do |x|
+      x.report("for:")   { for i in 1..n; a = "1"; end }
+      x.report("times:") { n.times do   ; a = "1"; end }
+      x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
+    end
+    array = (1..1000000).map { rand }
+    Benchmark.bmbm do |x|
+      #x.report("sort!") { array.dup.sort! } # TODO this causes a hang
+      #x.report("sort")  { array.dup.sort  }
+    end
+    Benchmark.benchmark(Benchmark::CAPTION, 7, Benchmark::FORMAT, ">total:", ">avg:") do |x|
+      tf = x.report("for:")   { for i in 1..n; a = "1"; end }
+      tt = x.report("times:") { n.times do   ; a = "1"; end }
+      tu = x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
+      [tf+tt+tu, (tf+tt+tu)/3]
+    end
+  end
+
+  def test_bigdecimal
+    # From the RUby stdlib documentation
+    BigDecimal.save_exception_mode do
+      BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
+      BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
+
+      BigDecimal.new(BigDecimal('Infinity'))
+      BigDecimal.new(BigDecimal('-Infinity'))
+      BigDecimal(BigDecimal.new('NaN'))
+    end
+    BigDecimal.save_limit do
+      BigDecimal.limit(200)
+    end
+    BigDecimal.save_rounding_mode do
+      BigDecimal.mode(BigDecimal::ROUND_MODE, :up)
+    end
+    # Additional test calls for coverage
+    BigDecimal.double_fig
+    BigDecimal.limit(5)
+    BigDecimal.mode(BigDecimal::EXCEPTION_NaN, true)
+    BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
+    BigDecimal.mode(BigDecimal::EXCEPTION_NaN)
+    BigDecimal.ver
+    
+    # TODO
+  end
+
+  def test_bigmath
+    # From the Ruby stdlib documentation
+    BigMath.E(10)
+    BigMath.PI(10)
+    BigMath.atan(BigDecimal.new('-1'), 16)
+    BigMath.cos(BigMath.PI(4), 16)
+    BigMath.sin(BigMath.PI(5)/4, 5)
+    BigMath.sqrt(BigDecimal.new('2'), 16)
+  end
+
+  def test_coverage
+    Coverage.start
+    Coverage.result
+    #Coverage.result # TODO This cannot be typechecked
+  end
+  
+  def test_set
+    assert_raises(RDL::Type::TypeError) { s6 = Set.new(1,2) }
+    # From the Ruby stdlib documentation
+    s1 = Set.new [1, 2]                   # -> #<Set: {1, 2}>
+    s2 = [1, 2].to_set                    # -> #<Set: {1, 2}>
+    s1 == s2                              # -> true
+    s1.add("foo")                         # -> #<Set: {1, 2, "foo"}>
+    s1.merge([2, 6])                      # -> #<Set: {1, 2, "foo", 6}>
+    s1.subset? s2                         # -> false
+    s2.subset? s1                         # -> true
+    Set[1, 2, 3].disjoint? Set[3, 4] # => false
+    Set[1, 2, 3].disjoint? Set[4, 5] # => true
+    numbers = Set[1, 3, 4, 6, 9, 10, 11]
+    set = numbers.divide { |i,j| (i - j).abs == 1 }
+    Set[1, 2, 3].intersect? Set[4, 5] # => false
+    Set[1, 2, 3].intersect? Set[3, 4] # => true
+    # Some more tests, just to make sure type checking doesn't cause crashes
+    s3 = s1 - s2
+    s1.proper_subset? s2
+    s1.superset? s2
+    s1 ^ s2
+    s1.add?("bar")
+    h = s1.classify { |x| x.size }
+    s2.clear
+    s4 = s1.map { |x| 42 }
+    s1.delete "foo"
+    s1.delete? "bar"
+    s1.delete_if { |x| false }
+    s1.each { |x| nil }
+    s1.empty?
+    s1.member? 42
+    s1.intersection [1,2,3]
+    s1.keep_if { |x| true }
+    s1.size
+    s1.difference [1,2,3]
+    s1.to_a
+    s5 = s1 + s2
+  end
+end

data/test/disabled_test_rdoc.rb

@@ -0,0 +1,116 @@
+require 'minitest/autorun'
+require 'rdoc'
+require 'erb'
+require 'fileutils'
+require 'pathname'
+require 'pp'
+require 'tempfile'
+require 'tmpdir'
+
+require 'rdoc'
+require_relative '../lib/rdl.rb'
+
+class RdocTest < MiniTest::Test
+
+  class TestClass
+    extend RDL
+    
+    typesig :size, "()->Fixnum"
+    typesig :bytesize, "()->Fixnum"
+  end
+
+  def test_rdoc_gen
+    skip "TEST WITH NO ASSERTIONS"
+    rdocTypesigFor(TestClass)
+  end
+end
+
+class TestRDLRDoc
+=begin
+    @have_encoding = Object.const_defined? :Encoding
+    @RM = RDoc::Markup
+    RDoc::Markup::PreProcess.reset
+    @pwd = Dir.pwd
+    @store = RDoc::Store.new
+    @rdoc = RDoc::RDoc.new
+    @rdoc.store = @store
+    @rdoc.options = RDoc::Options.new
+    
+    g = Object.new
+    def g.class_dir() end
+    def g.file_dir() end
+    @rdoc.generator = g
+    
+    @lib_dir = "#{@pwd}/lib"
+    $LOAD_PATH.unshift @lib_dir # ensure we load from this RDoc
+    
+    @options = RDoc::Options.new
+    @options.option_parser = OptionParser.new
+    
+    p Dir.tmpdir
+    @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_darkfish_#{$$}"
+    FileUtils.mkdir_p @tmpdir
+    Dir.chdir @tmpdir
+    @options.op_dir = @tmpdir
+    @options.generator = RDoc::Generator::Darkfish
+    
+    $LOAD_PATH.each do |path|
+    darkfish_dir = File.join path, 'rdoc/generator/template/darkfish/'
+        next unless File.directory? darkfish_dir
+        @options.template_dir = darkfish_dir
+        break
+    end
+
+    @rdoc.options = @options
+
+    @g = @options.generator.new @store, @options
+    @rdoc.generator = @g
+
+    @top_level = @store.add_file 'file.rb'
+    @top_level.parser = RDoc::Parser::Ruby
+    klass = @top_level.add_class RDoc::NormalClass, 'RDL_TEST_Klass(String)'
+
+    alis_constant = RDoc::Constant.new 'ABC', nil, ''
+    alis_constant.record_location @top_level
+
+    @top_level.add_constant alis_constant
+
+    klass.add_module_alias klass, 'AAA', @top_level
+
+    meth = RDoc::AnyMethod.new nil, 'Size'
+    tmthd = String.instance_variable_get(:@__typesigs)[:size]
+    msig = "()->#{tmthd.ret}"
+    eval "
+    def meth.param_seq
+        return \"%s\"
+    end
+    def meth.comment
+        true
+    end
+    def meth.description
+        return \"%s\"
+    end
+" % [msig,"Takes input {Params} and outputs {Return}"]
+
+    meth_bang = RDoc::AnyMethod.new nil, 'method!'
+    attr = RDoc::Attr.new nil, 'attr', 'RW', ''
+
+    klass.add_method meth
+    klass.add_method meth_bang
+    klass.add_attribute attr
+
+    ignored = @top_level.add_class RDoc::NormalClass, 'Ignored'
+    ignored.ignore
+
+    #@store.complete :private
+
+    @object      = @store.find_class_or_module 'Object'
+    klass_alias = @store.find_class_or_module 'Klass::A'
+
+    top_level = @store.add_file 'file.rb'
+    top_level.add_class klass.class, klass.name
+
+    @g.generate
+    p File.file?('index.html')
+=end
+end

data/test/test_alias.rb

@@ -0,0 +1,66 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestAlias < Minitest::Test
+
+  def test_alias_lookup
+    self.class.class_eval {
+      rdl_alias :foobar1, :foobar
+      rdl_alias :foobar2, :foobar
+      rdl_alias :foobar3, :foobar2
+      rdl_alias :foobar4, :foobar3
+      rdl_alias :foobar5, :foobar2
+    }
+    assert_equal :foobar, RDL::Wrap.resolve_alias(TestAlias, :foobar)
+    assert_equal :foobar, RDL::Wrap.resolve_alias(TestAlias, :foobar1)
+    assert_equal :foobar, RDL::Wrap.resolve_alias(TestAlias, :foobar2)
+    assert_equal :foobar, RDL::Wrap.resolve_alias(TestAlias, :foobar3)
+    assert_equal :foobar, RDL::Wrap.resolve_alias(TestAlias, :foobar4)
+    assert_equal :foobar, RDL::Wrap.resolve_alias(TestAlias, :foobar5)
+  end
+
+  def test_basic_alias_contract
+    self.class.class_eval {
+      pre { |x| x > 0 }
+      def m1(x) return x; end
+      alias_method :m2, :m1
+    }
+    assert_equal 3, m2(3)
+    assert_raises(RDL::Contract::ContractError) { m2(-1) }
+    self.class.class_eval { alias m3 m1 }
+    assert_equal 3, m3(3)
+    assert_raises(RDL::Contract::ContractError) { m3(-1) }
+  end
+
+  def test_existing_alias_contract
+    self.class.class_eval {
+      def m4(x) return x; end
+      alias_method :m5, :m4
+      rdl_alias :m5, :m4
+      pre(:m4) { |x| x > 0 }
+    }
+    assert_equal 3, m5(3)
+    assert_raises(RDL::Contract::ContractError) { m5(-1) }
+
+    def m6(x) return x; end
+    self.class.class_eval {
+      alias m7 m6
+      rdl_alias :m7, :m6
+      pre(:m6) { |x| x > 0 }
+    }
+    assert_equal 3, m7(3)
+    assert_raises(RDL::Contract::ContractError) { m7(-1) }
+
+    def m8(x) return x; end
+    self.class.class_eval {
+      alias_method :m9, :m8
+      rdl_alias :m9, :m8
+      alias_method :m10, :m9
+      rdl_alias :m10, :m9
+      pre(:m8) { |x| x > 0 }
+    }
+    assert_equal 3, m10(3)
+    assert_raises(RDL::Contract::ContractError) { m10(-1) }
+  end
+  
+end

data/test/test_contract.rb

@@ -0,0 +1,70 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestContract < Minitest::Test
+  include RDL::Contract
+
+  def test_flat
+    pos = FlatContract.new("Positive") { |x| x > 0 }
+    assert_equal "Positive", pos.to_s
+    assert_raises(ContractError) { pos.check self, 0 }
+    assert (pos.check self, 1)
+    gt = FlatContract.new("Greater Than") { |x, y| x > y }
+    assert (gt.check self, 4, 3)
+    assert_raises(ContractError) { gt.check self, 3, 4 }
+  end
+
+  def test_and
+    pos = FlatContract.new("Positive") { |x| x > 0 }
+    five = FlatContract.new("Five") { |x| x == 5 }
+    gt = FlatContract.new("Greater Than 3") { |x| x > 3 }
+    posfive = AndContract.new(pos, five)
+    assert_equal "Positive && Five", posfive.to_s
+    posfivegt = AndContract.new(pos, five, gt)
+    assert (posfive.check self, 5)
+    assert_raises(ContractError) { posfive.check self, 4 }
+    assert (posfivegt.check self, 5)
+    assert_raises(ContractError) { posfivegt.check self, 4 }
+  end
+  
+  def test_or
+    pos = FlatContract.new("Positive") { |x| x > 0 }
+    zero = FlatContract.new("Zero") { |x| x == 0 }
+    neg = FlatContract.new("Neg") { |x| x < 0 }
+    poszero = OrContract.new(pos, zero)
+    assert_equal "Positive && Zero", poszero.to_s
+    poszeroneg = OrContract.new(pos, zero, neg)
+    assert (poszero.check self, 1)
+    assert (poszero.check self, 0)
+    assert_raises(ContractError) { poszero.check self, (-1) }
+    assert (poszeroneg.check self, (-1))
+  end
+
+  def test_proc
+    pos = FlatContract.new("Positive") { |x| x > 0 }
+    neg = FlatContract.new("Negative") { |ret, x| ret < 0 }
+    pc = ProcContract.new(pre_cond: pos, post_cond: neg)
+    proc1 = pc.wrap(self) { |x| -x }
+    assert (proc1.call(42))
+    assert_raises(ContractError) { proc1.call(-42) }
+    proc2 = pc.wrap(self) { |x| x }
+    assert_raises(ContractError) { proc2.call(42) }
+  end
+
+  def test_proc_with_block
+    skip "Not working yet."
+    pos = FlatContract.new("Positive") { |x| x > 0 }
+    pc = ProcContract.new(pre_cond: pos)
+    proc = pc.wrap(self) { |x, &blk| blk.call(x) }
+    assert_equal 42, (proc.call(42) { |y| y })
+  end
+  
+  def test_turn_off
+    foo = FlatContract.new("Foo") {
+      pos = FlatContract.new("Positive") { |x| x > 0 }
+      pos.check self, -42
+      true
+    }
+    assert_equal true, foo.check(self)
+  end
+end