enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-range-ext/test/range.rb

@@ -0,0 +1,211 @@
+##
+# Range(Ext) Test
+
+assert('Range#cover?') do
+  assert_true ("a".."z").cover?("c")
+  assert_false ("a".."z").cover?("5")
+  assert_true ("a".."z").cover?("cc")
+  assert_false ("a".."z").cover?(nil)
+  assert_true ("a"..).cover?("c")
+  assert_false ("a"..).cover?("5")
+  assert_true ("a"..).cover?("cc")
+  assert_true (.."z").cover?("a")
+  assert_false (..."z").cover?("z")
+  assert_true (.."z").cover?("z")
+  assert_true (nil..nil).cover?(nil)
+
+  assert_true ("a".."c").cover?("b".."d")
+  assert_true ("a"..).cover?("b"..)
+  assert_false ("a"..).cover?(1..)
+  assert_false ("d"..).cover?(.."b")
+  assert_true (.."c").cover?("b".."d")
+  assert_true (.."c").cover?(.."d")
+  assert_false (.."c").cover?(..2)
+  assert_false (.."c").cover?("d"..)
+end
+
+assert('Range#first') do
+  assert_equal 10, (10..20).first
+  assert_equal [10, 11, 12], (10..20).first(3)
+  assert_equal 10, (10..).first
+  assert_equal [10, 11, 12], (10..).first(3)
+  assert_raise(RangeError) { (..1).first }
+
+  skip unless Object.const_defined?(:Float)
+  assert_equal [0, 1, 2], (0..Float::INFINITY).first(3)
+end
+
+assert('Range#last') do
+  assert_equal 20, (10..20).last
+  assert_equal 20, (10...20).last
+  assert_raise(RangeError) { (10..).last }
+  assert_raise(RangeError) { (10...).last }
+  assert_equal [18, 19, 20], (10..20).last(3)
+  assert_equal [17, 18, 19], (10...20).last(3)
+end
+
+assert('Range#size') do
+  assert_equal 42, (1..42).size
+  assert_equal 41, (1...42).size
+  assert_nil ('a'..'z').size
+  assert_nil ('a'..).size
+
+  assert_nil (1..).size unless Object.const_defined?(:Float)
+
+  skip unless Object.const_defined?(:Float)
+  assert_equal 6, (1...6.3).size
+  assert_equal 5, (1...6.0).size
+  assert_equal Float::INFINITY, (0..Float::INFINITY).size
+
+  assert_equal Float::INFINITY, (1..).size
+  assert_equal Float::INFINITY, (1...).size
+end
+
+assert('Range#max') do
+  # returns the maximum value in the range when called with no arguments
+  assert_equal 10, (1..10).max
+  assert_equal 9, (1...10).max
+  assert_equal 536870911, (0...2**29).max
+
+  # returns nil when the endpoint is less than the start point
+  assert_equal nil, (100..10).max
+
+  # returns nil when the endpoint equals the start point and the range is exclusive
+  assert_equal nil, (5...5).max
+
+  # returns the endpoint when the endpoint equals the start point and the range is inclusive
+  assert_equal 5, (5..5).max
+
+  # raises RangeError when called on an endless range
+  assert_raise(RangeError) { (10..).max }
+  assert_raise(RangeError) { (10...).max }
+
+  skip unless Object.const_defined?(:Float)
+
+  # returns the maximum value in the Float range when called with no arguments
+  assert_equal 908.1111, (303.20..908.1111).max
+
+  # raises TypeError when called on an exclusive range and a non Integer value
+  assert_raise(TypeError) { (303.20...908.1111).max }
+
+  # returns nil when the endpoint is less than the start point in a Float range
+  assert_equal nil, (3003.20..908.1111).max
+end
+
+assert('Range#max given a block') do
+  # passes each pair of values in the range to the block
+  acc = []
+  (1..10).max do |a, b|
+    acc << a
+    acc << b
+    a
+  end
+  (1..10).each do |value|
+    assert_true acc.include?(value)
+  end
+
+  # passes each pair of elements to the block in reversed order
+  acc = []
+  (1..5).max do |a, b|
+    acc << [a, b]
+    a
+  end
+  assert_equal [[2, 1], [3, 2], [4, 3], [5, 4]], acc
+
+  # returns the element the block determines to be the maximum
+  assert_equal 1, ((1..3).max { |_a, _b| -3 })
+
+  # returns nil when the endpoint is less than the start point
+  assert_equal nil, ((100..10).max { |x, y| x <=> y })
+  assert_equal nil, ((5...5).max { |x, y| x <=> y })
+end
+
+assert('Range#min') do
+  # returns the minimum value in the range when called with no arguments
+  assert_equal 1, (1..10).min
+  assert_equal 1, (1...10).min
+  assert_equal 1, (1..).min
+
+  # returns nil when the start point is greater than the endpoint
+  assert_equal nil, (100..10).min
+
+  # returns nil when the endpoint equals the start point and the range is exclusive
+  assert_equal nil, (5...5).min
+
+  # returns the endpoint when the endpoint equals the start point and the range is inclusive
+  assert_equal 5, (5..5).min
+
+  skip unless Object.const_defined?(:Float)
+
+  # returns the minimum value in the Float range when called with no arguments
+  assert_equal 303.20, (303.20..908.1111).min
+  assert_equal 1, (1.0..).min
+
+  # returns nil when the start point is greater than the endpoint in a Float range
+  assert_equal nil, (3003.20..908.1111).min
+end
+
+assert('Range#min given a block') do
+  # raise when called with a block in endless range
+  assert_raise(RangeError) { (1..).min{} }
+
+  # passes each pair of values in the range to the block
+  acc = []
+  (1..10).min do |a, b|
+    acc << a
+    acc << b
+    a
+  end
+  (1..10).each do |value|
+    assert_true acc.include?(value)
+  end
+
+  # passes each pair of elements to the block in reversed order
+  acc = []
+  (1..5).min do |a, b|
+    acc << [a, b]
+    a
+  end
+  assert_equal [[2, 1], [3, 1], [4, 1], [5, 1]], acc
+
+  # returns the element the block determines to be the minimum
+  assert_equal 3, ((1..3).min { |_a, _b| -3 })
+
+  # returns nil when the start point is greater than the endpoint
+  assert_equal nil, ((100..10).min { |x, y| x <=> y })
+  assert_equal nil, ((5...5).min { |x, y| x <=> y })
+end
+
+assert('Range#overlap?') do
+  assert_false((0..2).overlap?(-2..-1))
+  assert_false((0..2).overlap?(-2...0))
+  assert_true((0..2).overlap?(-1..0))
+  assert_true((0..2).overlap?(1..2))
+  assert_true((0..2).overlap?(2..3))
+  assert_false((0..2).overlap?(3...4))
+  assert_false((0...2).overlap?(2..3))
+
+  assert_true((..0).overlap?(-1..0))
+  assert_true((...0).overlap?(-1..0))
+  assert_true((..0).overlap?(0..1))
+  assert_true((..0).overlap?(..1))
+  assert_false((..0).overlap?(1..2))
+  assert_false((...0).overlap?(0..1))
+
+  assert_false((0..).overlap?(-2..-1))
+  assert_false((0..).overlap?(...0))
+  assert_true((0..).overlap?(..0))
+  assert_true((0..).overlap?(0..1))
+  assert_true((0..).overlap?(1..2))
+  assert_true((0..).overlap?(-1..0))
+  assert_true((0..).overlap?(1..))
+
+  assert_true((0..).overlap?(-1..0))
+  assert_true((0..).overlap?(..0))
+  assert_true((0..).overlap?(0..1))
+  assert_true((0..).overlap?(1..2))
+  assert_true((0..).overlap?(1..))
+
+  assert_raise(TypeError) { (0..).overlap?(1) }
+  assert_raise(TypeError) { (0..).overlap?(nil) }
+end

data/ext/enclave/mruby/mrbgems/mruby-rational/README.md

@@ -0,0 +1,61 @@
+# mruby-rational
+
+This mrbgem provides a `Rational` class for mruby, allowing you to work with rational numbers (fractions).
+
+## Usage
+
+To use the `Rational` class, you first need to include the mrbgem in your mruby build.
+
+### Include in build_config.rb
+
+Add the following line to your `build_config.rb` file:
+
+```ruby
+conf.gem :core => 'mruby-rational'
+```
+
+### Creating Rational Objects
+
+You can create `Rational` objects using the `Rational()` method:
+
+```ruby
+r1 = Rational(1, 2)  # Represents 1/2
+r2 = Rational(3, 4)  # Represents 3/4
+```
+
+### Arithmetic Operations
+
+The `Rational` class supports standard arithmetic operations:
+
+```ruby
+r_add = Rational(1, 2) + Rational(1, 3)  # (5/6)
+r_sub = Rational(1, 2) - Rational(1, 3)  # (1/6)
+r_mul = Rational(1, 2) * Rational(1, 3)  # (1/6)
+r_div = Rational(1, 2) / Rational(1, 3)  # (3/2)
+```
+
+## Available Methods
+
+The `Rational` class provides the following important methods:
+
+- `numerator`: Returns the numerator of the rational number.
+- `denominator`: Returns the denominator of the rational number.
+- `to_f`: Converts the rational number to a `Float`.
+- `to_i`: Converts the rational number to an `Integer` (truncates towards zero).
+- `to_s`: Returns a string representation of the rational number (e.g., "1/2").
+- `inspect`: Returns a string representation suitable for debugging (e.g., "(1/2)").
+- `==`: Checks for equality with another number.
+- `<=>`: Compares the rational number with another number.
+- `positive?`: Returns `true` if the rational number is greater than zero.
+- `negative?`: Returns `true` if the rational number is less than zero.
+
+## Error Handling
+
+The mrbgem handles common errors such as:
+
+- **DivisionByZeroError**: Raised when attempting to create a rational number with a denominator of zero.
+- **RangeError**: Raised in case of integer overflow during calculations.
+
+## License
+
+mruby-rational is licensed under the MIT License. See LICENSE for details.

data/ext/enclave/mruby/mrbgems/mruby-rational/mrbgem.rake

@@ -0,0 +1,7 @@
+MRuby::Gem::Specification.new('mruby-rational') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Rational class'
+  spec.build.defines << "MRB_USE_RATIONAL"
+  spec.add_test_dependency('mruby-complex', :core => 'mruby-complex')
+end

data/ext/enclave/mruby/mrbgems/mruby-rational/mrblib/rational.rb

@@ -0,0 +1,66 @@
+class Rational < Numeric
+  #
+  # call-seq:
+  #   rat.inspect -> string
+  #
+  # Returns the value as a string for inspection.
+  #
+  #   Rational(2).inspect      #=> "(2/1)"
+  #   Rational(-8, 6).inspect  #=> "(-4/3)"
+  #   Rational(1, 2).inspect   #=> "(1/2)"
+  #
+  def inspect
+    "(#{to_s})"
+  end
+
+  #
+  # call-seq:
+  #   rat.to_s -> string
+  #
+  # Returns the value as a string.
+  #
+  #   Rational(2).to_s      #=> "2/1"
+  #   Rational(-8, 6).to_s  #=> "-4/3"
+  #   Rational(1, 2).to_s   #=> "1/2"
+  #
+  def to_s
+    "#{numerator}/#{denominator}"
+  end
+
+  #
+  # call-seq:
+  #   rat <=> numeric -> -1, 0, +1, or nil
+  #
+  # Returns -1, 0, or +1 depending on whether rat is less than, equal to,
+  # or greater than numeric. This is the basis for the tests in the Comparable module.
+  # Returns nil if the two values are incomparable.
+  #
+  #   Rational(2, 3) <=> Rational(2, 3)  #=> 0
+  #   Rational(5) <=> 5                  #=> 0
+  #   Rational(2, 3) <=> Rational(1, 3)  #=> 1
+  #   Rational(1, 3) <=> 1               #=> -1
+  #   Rational(1, 3) <=> 0.3             #=> 1
+  #
+  def <=>(other)
+    return nil unless other.kind_of?(Numeric)
+    self.to_f <=> other.to_f
+  rescue
+    nil
+  end
+end
+
+class Numeric
+  #
+  # call-seq:
+  #   num.to_r -> rational
+  #
+  # Returns the value as a rational.
+  #
+  #   1.to_r        #=> (1/1)
+  #   (1+2i).to_r   #=> (1+2i)/1)
+  #   nil.to_r      #=> TypeError
+  #
+  def to_r
+    Rational(self, 1)
+  end
+end