rdl 2.0.1 → 2.1.0

data/lib/types/core-ruby-2.x/bigmath.rb

@@ -1,12 +0,0 @@
-module BigMath
-  rdl_nowrap
-
-  type 'self.exp', '(Fixnum, Fixnum) -> BigDecimal'
-  type 'self.log', '(Fixnum, Fixnum) -> BigDecimal'
-  type :E, '(Fixnum) -> BigDecimal'
-  type :PI, '(Fixnum) -> BigDecimal'
-  type :atan, '(Fixnum, Fixnum) -> BigDecimal'
-  type :cos, '(Fixnum, Fixnum) -> BigDecimal'
-  type :sin, '(Fixnum, Fixnum) -> BigDecimal'
-  type :sqrt, '(Fixnum, Fixnum) -> BigDecimal'
-end

data/lib/types/core-ruby-2.x/bignum.rb

@@ -1,214 +0,0 @@
-class Bignum < Integer
-  rdl_nowrap
-
-  type :%, '(Fixnum x {{ x!=0 }}) -> Fixnum'
-  type :%, '(Bignum x {{ x!=0 }}) -> %integer'
-  type :%, '(Float x {{ x!=0 }}) -> Float'
-  type :%, '(Rational x {{ x!=0 }}) -> Rational'
-  type :%, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
-
-  type :&, '(%integer) -> Fixnum'
-
-  type :*, '(Fixnum) -> %integer'
-  type :*, '(Bignum) -> Bignum'
-  type :*, '(Float) -> Float'
-  type :*, '(Rational) -> Rational'
-  type :*, '(BigDecimal) -> BigDecimal'
-  type :*, '(Complex) -> Complex'
-  pre(:*) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end} #can't have a complex with part BigDecimal, other part infinity/NAN
-
-  type :**, '(%integer) -> %numeric'
-  type :**, '(Float) -> %numeric'
-  type :**, '(Rational) -> %numeric'
-  type :**, '(BigDecimal) -> BigDecimal'
-  pre(:**) { |x| x!=BigDecimal::INFINITY && if self<0 then x<=-1||x>=0 else true end}
-  post(:**) { |r,x| r.real?}
-  type :**, '(Complex) -> Complex'
-  pre(:**) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end}
-
-  type :+, '(%integer) -> %integer'
-  type :+, '(Float) -> Float'
-  type :+, '(Rational) -> Rational'
-  type :+, '(BigDecimal) -> BigDecimal'
-  type :+, '(Complex) -> Complex'
-
-  type :-, '(%integer) -> %integer'
-  type :-, '(Float) -> Float'
-  type :-, '(Rational) -> Rational'
-  type :-, '(BigDecimal) -> BigDecimal'
-  type :-, '(Complex) -> Complex'
-
-  type :-, '() -> %integer'
-
-  type :/, '(%integer x {{ x!=0 }}) -> %integer'
-  type :/, '(Float x {{ x!=0 }}) -> Float'
-  type :/, '(Rational x {{ x!=0 }}) -> Rational'
-  type :/, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
-  type :/, '(Complex x {{ x!=0 }}) -> Complex'
-  pre(:/) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
-
-  type :<, '(%integer) -> %bool'
-  type :<, '(Float) -> %bool'
-  type :<, '(Rational) -> %bool'
-  type :<, '(BigDecimal) -> %bool'
-
-  type :<<, '(Fixnum) -> %integer'
-
-  type :<=, '(%integer) -> %bool'
-  type :<=, '(Float) -> %bool'
-  type :<=, '(Rational) -> %bool'
-  type :<=, '(BigDecimal) -> %bool'
-
-  type :<=>, '(%integer) -> Object'
-  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
-  type :<=>, '(Float) -> Object'
-  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
-  type :<=>, '(Rational) -> Object'
-  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
-  type :<=>, '(BigDecimal) -> Object'
-  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
-
-  type :==, '(Object) -> %bool'
-
-  type :===, '(Object) -> %bool'
-
-  type :>, '(%integer) -> %bool'
-  type :>, '(Float) -> %bool'
-  type :>, '(Rational) -> %bool'
-  type :>, '(BigDecimal) -> %bool'
-
-  type :>=, '(%integer) -> %bool'
-  type :>=, '(Float) -> %bool'
-  type :>=, '(Rational) -> %bool'
-  type :>=, '(BigDecimal) -> %bool'
-
-  type :>>, '(%integer) -> %integer'
-  post(:>>) { |r,x| r >= 0 }
-
-  type :[], '(%integer) -> Fixnum'
-  post(:[]) { |r,x| r == 0 || r==1}
-  type :[], '(Rational) -> Fixnum'
-  post(:[]) { |r,x| r == 0 || r==1}
-  type :[], '(Float) -> Fixnum'
-  pre(:[]) { |x| x!=Float::INFINITY && !x.nan? }
-  post(:[]) { |r,x| r == 0 || r==1}
-  type :[], '(BigDecimal) -> Fixnum'
-  pre(:[]) { |x| x!=BigDecimal::INFINITY && !x.nan? }
-  post(:[]) { |r,x| r == 0 || r==1}
-
-  type :^, '(%integer) -> %integer'
-
-  type :|, '(%integer) -> %integer'
-
-  type :~, '() -> Bignum'
-
-  type :abs, '() -> Bignum r {{ r>=0 }}'
-
-  type :bit_length, '() -> %integer r {{ r>=0 }}'
-
-  type :div, '(%integer x {{ x!=0 }}) -> %integer'
-  type :div, '(Float x {{ x!=0 && !x.nan? }}) -> %integer'
-  type :div, '(Rational x {{ x!=0 }}) -> %integer'
-  type :div, '(BigDecimal x {{ x!=0 && !x.nan?}}) -> %integer'
-
-  type :divmod, '(%real) -> [%real, %real]'
-  pre(:divmod) { |x| x!=0 && if x.is_a?(Float) then !x.nan? else true end}
-
-  type :even?, '() -> %bool'
-
-  type :fdiv, '(%integer) -> Float'
-  type :fdiv, '(Float) -> Float'
-  type :fdiv, '(Rational) -> Float'
-  type :fdiv, '(BigDecimal) -> BigDecimal'
-  type :fdiv, '(Complex) -> Complex'
-  pre(:fdiv) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
-
-  type :to_s, '() -> String'
-  type :inspect, '() -> String'
-
-  type :magnitude, '() -> Bignum'
-  post(:magnitude) { |r,x| r >= 0 }
-
-  type :modulo, '(Fixnum x {{ x!=0 }}) -> Fixnum'
-  type :modulo, '(Bignum x {{ x!=0 }}) -> %integer'
-  type :modulo, '(Float x {{ x!=0 }}) -> Float'
-  type :modulo, '(Rational x {{ x!=0 }}) -> Rational'
-  type :modulo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
-
-  type :next, '() -> %integer'
-
-  type :odd?, '() -> %bool'
-
-  type :size, '() -> %integer'
-
-  type :succ, '() -> %integer'
-
-  type :to_f, '() -> Float'
-
-  type :zero?, '() -> %bool'
-
-  type :ceil, '() -> %integer'
-
-  type :denominator, '() -> Fixnum r {{ r==1 }}'
-
-  type :floor, '() -> %integer'
-
-  type :numerator, '() -> Bignum'
-
-  type :quo, '(%integer x {{ x!=0 }}) -> Rational'
-  type :quo, '(Float x {{ x!=0 }}) -> Float'
-  type :quo, '(Rational x {{ x!=0 }}) -> Rational'
-  type :quo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
-  type :quo, '(Complex x {{ x!=0 }}) -> Complex'
-  pre(:quo) { if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
-
-  type :rationalize, '() -> Rational'
-
-  type :rationalize, '(%numeric) -> Rational'
-
-  type :round, '() -> %integer'
-
-  type :round, '(%numeric) -> %numeric'
-  pre(:round) { |x| x!=0 && if x.is_a?(Complex) then x.imaginary==0 && (if x.real.is_a?(Float)||x.real.is_a?(BigDecimal) then !x.real.infinite? && !x.real.nan? else true end) elsif x.is_a?(Float) then x!=Float::INFINITY && !x.nan? elsif x.is_a?(BigDecimal) then x!=BigDecimal::INFINITY && !x.nan? else true end} #Also, x must be in range [-2**31, 2**31].
-
-  type :to_i, '() -> Bignum'
-
-  type :to_r, '() -> Rational'
-
-  type :truncate, '() -> %integer'
-
-  type :angle, '() -> %numeric'
-  post(:angle) { |r,x| r == 0 || r == Math::PI}
-
-  type :arg, '() -> %numeric'
-  post(:arg) { |r,x| r == 0 || r == Math::PI}
-
-  type :equal?, '(Object) -> %bool'
-  type :eql?, '(Object) -> %bool'
-
-  type :hash, '() -> %integer'
-
-  type :phase, '() -> %numeric'
-
-  type :abs2, '() -> Bignum r {{ r>=0 }}'
-
-  type :conj, '() -> Bignum'
-  type :conjugate, '() -> Bignum'
-
-  type :imag, '() -> Fixnum r {{ r==0 }}'
-  type :imaginary, '() -> Fixnum r {{ r==0 }}'
-
-  type :real, '() -> Bignum'
-
-  type :real?, '() -> true'
-
-  type :to_c, '() -> Complex r {{ r.imaginary==0 }}'
-
-  type :remainder, '(Fixnum x {{ x!=0 }}) -> Fixnum r {{ r>=0 }}'
-  type :remainder, '(Bignum x {{ x!=0 }}) -> Fixnum r {{ r>=0 }}'
-  type :remainder, '(Float x {{ x!=0 }}) -> Float'
-  type :remainder, '(Rational x {{ x!=0 }}) -> Rational r {{ r>=0 }}'
-  type :remainder, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
-
-  type :coerce, '(%integer) -> [%integer, %integer]'
-end

data/lib/types/core-ruby-2.x/class.rb

@@ -1,17 +0,0 @@
-class Class
-  rdl_nowrap
-
-  type :allocate, '() -> %any' # Instance of class self
-  type :inherited, '(Class) -> %any'
-  #type 'initialize', '() -> '
-  #type 'new', '(*%any) -> %any' #Causes two other test cases to fail
-  type :superclass, '() -> Class or nil'
-
-  #  type :class_eval, '() {() -> %any} -> %any'
-  #  type :method_defined?, '(String or Symbol) -> %bool'
-  #  type :define_method, '(String or Symbol) {(*%any) -> %any} -> Proc'
-  type :instance_methods, '(?%bool) -> Array<Symbol>'
-  type :class, '() -> Class'
-  type :superclass, '() -> Class'
-  type :name, '() -> String'
-end

data/lib/types/core-ruby-2.x/complex.rb

@@ -1,124 +0,0 @@
-class Complex < Numeric
-  rdl_nowrap
-
-  type :*, '(%integer) -> Complex'
-  type :*, '(Float) -> Complex'
-  pre(:*) { |x| if x.infinite?||x.nan? then !self.imaginary.is_a?(BigDecimal)&&!self.real.is_a?(BigDecimal) else true end}
-  type :*, '(Rational) -> Complex'
-  type :*, '(BigDecimal) -> Complex'
-  pre(:*) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? elsif x.imaginary.is_a?(Float) then !x.imaginary.infinite? && !x.imaginary.nan? else true end}
-  type :*, '(Complex) -> Complex'
-  pre(:*) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end}
-
-  type :**, '(%integer) -> Complex'
-  type :**, '(Float) -> Complex'
-  type :**, '(Rational) -> Complex'
-  type :**, '(BigDecimal x {{ !x.infinite? && !x.nan? && x>=0 }}) -> Complex'
-  type :**, '(Complex) -> Complex'
-  pre(:**) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end}
-
-  type :+, '(%integer) -> Complex'
-  type :+, '(Float) -> Complex'
-  pre(:+) { |x| if x.infinite?||x.nan? then !self.real.is_a?(BigDecimal) else true end}
-  type :+, '(Rational) -> Complex'
-  type :+, '(BigDecimal) -> Complex'
-  pre(:+) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? else true end}
-  type :+, '(Complex) -> Complex'
-  pre(:+) { |x| if (x.real.is_a?(BigDecimal) && self.real.is_a?(Float)) then !(self.real.infinite?||self.real.nan?) elsif x.real.is_a?(Float)&&self.real.is_a?(BigDecimal) then !(x.real.infinite?||x.real.nan?) elsif (x.imaginary.is_a?(BigDecimal) && self.imaginary.is_a?(Float)) then !(self.imaginary.infinite?||self.imaginary.nan?) elsif x.imaginary.is_a?(Float)&&self.imaginary.is_a?(BigDecimal) then !(x.imaginary.infinite?||x.imaginary.nan?) else true end}
-
-  type :-, '(%integer) -> Complex'
-  type :-, '(Float) -> Complex'
-  pre(:-) { |x| if x.infinite?||x.nan? then !self.real.is_a?(BigDecimal) else true end}
-  type :-, '(Rational) -> Complex'
-  type :-, '(BigDecimal) -> Complex'
-  pre(:-) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? else true end}
-  type :-, '(Complex) -> Complex'
-  pre(:-) { |x| if (x.real.is_a?(BigDecimal) && self.real.is_a?(Float)) then !(self.real.infinite?||self.real.nan?) elsif x.real.is_a?(Float)&&self.real.is_a?(BigDecimal) then !(x.real.infinite?||x.real.nan?) elsif (x.imaginary.is_a?(BigDecimal) && self.imaginary.is_a?(Float)) then !(self.imaginary.infinite?||self.imaginary.nan?) elsif x.imaginary.is_a?(Float)&&self.imaginary.is_a?(BigDecimal) then !(x.imaginary.infinite?||x.imaginary.nan?) else true end}
-
-  type :-, '() -> Complex'
-
-  type :/, '(%integer x {{ x!=0 }}) -> Complex'
-  type :/, '(Float x {{ x!=0 }}) -> Complex'
-  pre(:/) { |x| if x.infinte?||x.nan? then !self.real.is_a?(BigDecimal) && !self.imaginary.is_a?(BigDecimal) else true end}
-  type :/, '(Rational x {{ x!=0 }}) -> Complex'
-  type :/, '(BigDecimal x {{ x!=0 }}) -> Complex'
-  pre(:/) { |x| if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.imaginary.nan? else true end}
-  type :/, '(Complex x {{ x!=0 }}) -> Complex'
-  pre(:/) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal) || self.real.is_a?(BigDecimal) || self.imaginary .is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) && if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.imaginary.nan? else true end else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
-
-  type:==, '(Object) -> %bool'
-
-  type :abs, '() -> %numeric r {{ r>=0 }}'
-
-  type :abs2, '() -> %numeric r {{ r>=0 }}'
-
-  type :angle, '() -> Float'
-
-  type :arg, '() -> Float'
-
-  type :conj, '() -> Complex'
-  type :conjugate, '() -> Complex'
-
-  type :denominator, '() -> %integer'
-
-  type :equal?, '(Object) -> %bool'
-  type :eql?, '(Object) -> %bool'
-
-  type :fdiv, '(%numeric) -> Complex'
-  pre(:fdiv) { |x| if (self.real.is_a?(Float) && (self.real.infinite? || self.real.nan?))||(self.imaginary.is_a?(Float) && (self.imaginary.infinite? || self.imaginary.nan?)) then !x.is_a?(BigDecimal) && (if x.is_a?(Complex) then !x.real.is_a?(BigDecimal) && !x.imaginary.is_a?(BigDecimal) else true end) else true end}
-
-  type :hash, '() -> %integer'
-
-  type :imag, '() -> %real'
-  type :imaginary, '() -> %real'
-
-  type :inspect, '() -> String'
-
-  type :magnitude, '() -> %real'
-
-  type :numerator, '() -> Complex'
-
-  type :phase, '() -> Float'
-
-  type :polar, '() -> [%real, %real]'
-
-
-  type :quo, '(%integer x {{ x!=0 }}) -> Complex'
-  type :quo, '(Float x {{ x!=0 }}) -> Complex'
-  pre(:quo) { |x| if self.real.is_a?(BigDecimal)||self.imaginary.is_a?(BigDecimal) then !x.infinite? && !x.nan? else true end}
-  type :quo, '(Rational x {{ x!=0 }}) -> Complex'
-  type :quo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
-  pre(:quo) { |x| if self.real.is_a?(Float) then !self.real.infinite?&&!self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.imaginary.nan? else true end}
-  type :quo, '(Complex x {{ x!=0 }}) -> Complex'
-  pre(:quo) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal) || self.real.is_a?(BigDecimal) || self.imaginary .is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) && if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.imaginary.nan? else true end else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
-
-  type :rationalize, '() -> Rational'
-  pre(:rationalize) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
-
-  type :rationalize, '(%numeric) -> Rational'
-  pre(:rationalize) { |x| self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(Rational) then (if x.is_a?(Float)||x.is_a?(BigDecimal) then !x.infinite? && !x.nan? else true end) else true end && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
-
-  type :real, '() -> %real'
-
-  type :real?, '() -> false'
-
-  type :rect, '() -> [%real, %real]'
-  type :rectangular, '() -> [%real, %real]'
-
-  type :to_c, '() -> Complex'
-
-  type :to_f, '() -> Float'
-  pre(:to_f) { self.imaginary==0}
-
-  type :to_i, '() -> %integer'
-  pre(:to_i) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
-
-  type :to_r, '() -> Rational'
-  pre(:to_r) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
-
-  type :to_s, '() -> String'
-
-  type :zero?, '() -> %bool'
-
-  type :coerce, '(%numeric) -> [Complex, Complex]'
-end

data/lib/types/core-ruby-2.x/coverage.rb

@@ -1,6 +0,0 @@
-module Coverage
-  rdl_nowrap
-
-  type 'self.start', '() -> nil'
-  type 'self.result', '() -> Hash<String,Array<Fixnum or nil>>'
-end

data/lib/types/core-ruby-2.x/csv.rb

@@ -1,5 +0,0 @@
-class CSV
-  rdl_nowrap
-
-  type 'self.foreach', '(String or File, ?Hash<Symbol, %any>) {(Array<String>) -> %any} -> NilClass'
-end

data/lib/types/core-ruby-2.x/date.rb

@@ -1,6 +0,0 @@
-class Date
-  rdl_nowrap
-
-  type 'self.now', '() -> DateTime'
-  type :strftime, '(String) -> String'
-end

data/lib/types/core-ruby-2.x/dir.rb

@@ -1,38 +0,0 @@
-class Dir
-  rdl_nowrap
-
-  rdl_alias :[], :glob
-  type 'self.chdir', '(?(String or Pathname)) -> 0'
-  type 'self.chdir', '(?(String or Pathname)) { (String) -> u } -> u'
-  type 'self.chroot', '(String) -> 0'
-  type 'self.delete', '(String) -> 0'
-  type 'self.entries', '(String, ?Encoding) -> Array<String>'
-  type 'self.exist?', '(String file) -> %bool'
-  # exists? deprecated
-  type 'self.foreach', '(String dir, ?Encoding) { (String) -> %any } -> nil'
-  type 'self.foreach', '(String dir, ?Encoding) -> Enumerator<String>'
-  type 'self.getwd', '() -> String'
-  type 'self.glob', '(String or Array<String> pattern, ?Fixum flags) -> Array<String>'
-  type 'self.glob', '(String or Array<String> pattern, ?Fixum flags) { (String) -> %any} -> nil'
-  type 'self.home', '(?String) -> String'
-  type 'self.mkdir', '(String, ?Fixnum) -> 0'
-  type 'self.new', '(String, ?Encoding) -> Dir'
-  type 'self.open', '(String, ?Encoding) -> Dir'
-  type 'self.open', '(String, ?Encoding) { (Dir) -> u } -> u'
-  type 'self.pwd', '() -> String'
-  type 'self.rmdir', '(String) -> 0'
-  type 'self.unlink', '(String) -> 0'
-  type :close, '() -> nil'
-  type :each, '() { (String) -> %any } -> self'
-  type :each, '() -> Enumerator<String>'
-  type :fileno, '() -> Fixnum'
-  type :inspect, '() -> String'
-  type :path, '() -> String or nil'
-  type :pos, '() -> Fixnum'
-  type :pos=, '(Fixnum) -> Fixnum'
-  type :read, '() -> String or nil'
-  type :rewind, '() -> self'
-  type :seek, '(Fixnum) -> self'
-  type :tell, '() -> Fixnum'
-  type :to_path, '() -> String or nil'
-end

data/lib/types/core-ruby-2.x/encoding.rb

@@ -1,23 +0,0 @@
-class Encoding
-  rdl_nowrap
-
-  type 'self.aliases', '() -> Hash<String, String>'
-  type 'self.compatible?', '(%any obj1, %any obj2) -> Encoding or nil'
-  type 'self.default_external', '() -> Encoding'
-  type 'self.default_external=', '(String) -> String'
-  type 'self.default_external=', '(Encoding) -> Encoding'
-  type 'self.default_internal', '() -> Encoding'
-  type 'self.default_internal=', '(String) -> String or nil'
-  type 'self.default_internal=', '(Encoding) -> Encoding or nil'
-  type 'self.find', '(String or Encoding) -> Encoding'
-  type 'self.list', '() -> Array<Encoding>'
-  type 'self.name_list', '() -> Array<String>'
-
-  type :ascii_compatible?, '() -> %bool'
-  type :dummy?, '() -> %bool'
-  type :inspect, '() -> String'
-  type :name, '() -> String'
-  type :names, '() -> Array<String>'
-  type :replicate, '(String name) -> Encoding'
-  rdl_alias :to_s, :name
-end