enclave 0.1.0

data/ext/enclave/mruby/mrblib/compar.rb

@@ -0,0 +1,102 @@
+##
+# Comparable
+#
+# ISO 15.3.3
+module Comparable
+
+  ##
+  # call-seq:
+  #   obj < other    -> true or false
+  #
+  # Return true if `self` is less
+  # than `other`. Otherwise return
+  # false.
+  #
+  # ISO 15.3.3.2.1
+  def < other
+    cmp = self <=> other
+    if cmp.nil?
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+    cmp < 0
+  end
+
+  ##
+  # call-seq:
+  #   obj <= other   -> true or false
+  #
+  # Return true if `self` is less
+  # than or equal to `other`.
+  # Otherwise return false.
+  #
+  # ISO 15.3.3.2.2
+  def <= other
+    cmp = self <=> other
+    if cmp.nil?
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+    cmp <= 0
+  end
+
+  ##
+  # call-seq:
+  #   obj == other   -> true or false
+  #
+  # Return true if `self` is equal
+  # to `other`. Otherwise return
+  # false.
+  #
+  # ISO 15.3.3.2.3
+  def == other
+    cmp = self <=> other
+    cmp.equal?(0)
+  end
+
+  ##
+  # call-seq:
+  #   obj > other    -> true or false
+  #
+  # Return true if `self` is greater
+  # than `other`. Otherwise return
+  # false.
+  #
+  # ISO 15.3.3.2.4
+  def > other
+    cmp = self <=> other
+    if cmp.nil?
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+    cmp > 0
+  end
+
+  ##
+  # call-seq:
+  #   obj >= other   -> true or false
+  #
+  # Return true if `self` is greater
+  # than or equal to `other`.
+  # Otherwise return false.
+  #
+  # ISO 15.3.3.2.5
+  def >= other
+    cmp = self <=> other
+    if cmp.nil?
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+    cmp >= 0
+  end
+
+  ##
+  # call-seq:
+  #   obj.between?(min,max) -> true or false
+  #
+  # Return true if `self` is greater
+  # than or equal to `min` and
+  # less than or equal to `max`.
+  # Otherwise return false.
+  #
+  # ISO 15.3.3.2.6
+  def between?(min, max)
+    self >= min and self <= max
+  end
+end

data/ext/enclave/mruby/mrblib/enum.rb

@@ -0,0 +1,358 @@
+##
+# Enumerable
+#
+# The `Enumerable` mixin provides collection classes with
+# several traversal and searching methods, and with the ability to
+# sort. The class must provide a method `each`, which
+# yields successive members of the collection. If
+# {Enumerable#max}, {#min}, or
+# {#sort} is used, the objects in the collection must also
+# implement a meaningful `<=>` operator, as these methods
+# rely on an ordering between members of the collection.
+#
+# ISO 15.3.2
+module Enumerable
+
+  NONE = Object.new
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each`. Return false
+  # if one block value is false. Otherwise
+  # return true. If no block is given and
+  # `self` is false return false.
+  #
+  # ISO 15.3.2.2.1
+  def all?(&block)
+    if block
+      self.each {|*val| return false unless block.call(*val)}
+    else
+      self.each {|*val| return false unless val.__svalue}
+    end
+    true
+  end
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each`. Return true
+  # if one block value is true. Otherwise
+  # return false. If no block is given and
+  # `self` is true object return true.
+  #
+  # ISO 15.3.2.2.2
+  def any?(&block)
+    if block
+      self.each {|*val| return true if block.call(*val)}
+    else
+      self.each {|*val| return true if val.__svalue}
+    end
+    false
+  end
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each`. Append all
+  # values of each block together and
+  # return this value.
+  #
+  # ISO 15.3.2.2.3
+  def collect(&block)
+    return to_enum(:collect) unless block
+
+    ary = []
+    self.each {|*val| ary.push(block.call(*val))}
+    ary
+  end
+
+  ##
+  # Return the first element for which
+  # value from the block is true. If no
+  # object matches, calls `ifnone` and
+  # returns its result. Otherwise returns
+  # `nil`.
+  #
+  # ISO 15.3.2.2.4
+  def detect(ifnone=nil, &block)
+    return to_enum(:detect, ifnone) unless block
+
+    self.each {|*val|
+      if block.call(*val)
+        return val.__svalue
+      end
+    }
+    ifnone.call unless ifnone.nil?
+  end
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each`. Pass an
+  # index to the block which starts at 0
+  # and increase by 1 for each element.
+  #
+  # ISO 15.3.2.2.5
+  def each_with_index(&block)
+    return to_enum(:each_with_index) unless block
+
+    i = 0
+    self.each {|*val|
+      block.call(val.__svalue, i)
+      i += 1
+    }
+    self
+  end
+
+  ##
+  # Return an array of all elements which
+  # are yield by `each`.
+  #
+  # ISO 15.3.2.2.6
+  def entries
+    ary = []
+    self.each {|*val|
+      # __svalue is an internal method
+      ary.push val.__svalue
+    }
+    ary
+  end
+
+  ##
+  # Alias for find
+  #
+  # ISO 15.3.2.2.7
+  alias find detect
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each`. Return an array
+  # which contains all elements whose block
+  # value was true.
+  #
+  # ISO 15.3.2.2.8
+  def find_all(&block)
+    return to_enum(:find_all) unless block
+
+    ary = []
+    self.each {|*val|
+      ary.push(val.__svalue) if block.call(*val)
+    }
+    ary
+  end
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each` and which return
+  # value was true when invoking === with
+  # `pattern`. Return an array with all
+  # elements or the respective block values.
+  #
+  # ISO 15.3.2.2.9
+  def grep(pattern, &block)
+    ary = []
+    self.each {|*val|
+      sv = val.__svalue
+      if pattern === sv
+        ary.push((block)? block.call(*val): sv)
+      end
+    }
+    ary
+  end
+
+  ##
+  # Return true if at least one element which
+  # is yield by `each` returns a true value
+  # by invoking == with `obj`. Otherwise return
+  # false.
+  #
+  # ISO 15.3.2.2.10
+  def include?(obj)
+    self.each {|*val|
+      return true if val.__svalue == obj
+    }
+    false
+  end
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each`. Return value
+  # is the sum of all block values. Pass
+  # to each block the current sum and the
+  # current element.
+  #
+  # ISO 15.3.2.2.11
+  def inject(*args, &block)
+    raise ArgumentError, "too many arguments" if args.size > 2
+    if Symbol === args[-1]
+      sym = args[-1]
+      block = ->(x,y){x.__send__(sym,y)}
+      args.pop
+    end
+    if args.empty?
+      flag = true  # no initial argument
+      result = nil
+    else
+      flag = false
+      result = args[0]
+    end
+    self.each {|*val|
+      val = val.__svalue
+      if flag
+        # push first element as initial
+        flag = false
+        result = val
+      else
+        result = block.call(result, val)
+      end
+    }
+    result
+  end
+  alias reduce inject
+
+  ##
+  # Alias for collect
+  #
+  # ISO 15.3.2.2.12
+  alias map collect
+
+  ##
+  # Return the maximum value of all elements
+  # yield by `each`. If no block is given <=>
+  # will be invoked to define this value. If
+  # a block is given it will be used instead.
+  #
+  # ISO 15.3.2.2.13
+  def max(&block)
+    flag = true  # 1st element?
+    result = nil
+    self.each {|*val|
+      val = val.__svalue
+      if flag
+        # 1st element
+        result = val
+        flag = false
+      else
+        if block
+          result = val if block.call(val, result) > 0
+        else
+          result = val if (val <=> result) > 0
+        end
+      end
+    }
+    result
+  end
+
+  ##
+  # Return the minimum value of all elements
+  # yield by `each`. If no block is given <=>
+  # will be invoked to define this value. If
+  # a block is given it will be used instead.
+  #
+  # ISO 15.3.2.2.14
+  def min(&block)
+    flag = true  # 1st element?
+    result = nil
+    self.each {|*val|
+      val = val.__svalue
+      if flag
+        # 1st element
+        result = val
+        flag = false
+      else
+        if block
+          result = val if block.call(val, result) < 0
+        else
+          result = val if (val <=> result) < 0
+        end
+      end
+    }
+    result
+  end
+
+  ##
+  # Alias for include?
+  #
+  # ISO 15.3.2.2.15
+  alias member? include?
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each`. Return an
+  # array which contains two arrays. The
+  # first array contains all elements
+  # whose block value was true. The second
+  # array contains all elements whose
+  # block value was false.
+  #
+  # ISO 15.3.2.2.16
+  def partition(&block)
+    return to_enum(:partition) unless block
+
+    ary_T = []
+    ary_F = []
+    self.each {|*val|
+      if block.call(*val)
+        ary_T.push(val.__svalue)
+      else
+        ary_F.push(val.__svalue)
+      end
+    }
+    [ary_T, ary_F]
+  end
+
+  ##
+  # Call the given block for each element
+  # which is yield by `each`. Return an
+  # array which contains only the elements
+  # whose block value was false.
+  #
+  # ISO 15.3.2.2.17
+  def reject(&block)
+    return to_enum(:reject) unless block
+
+    ary = []
+    self.each {|*val|
+      ary.push(val.__svalue) unless block.call(*val)
+    }
+    ary
+  end
+
+  ##
+  # Alias for find_all.
+  #
+  # ISO 15.3.2.2.18
+  alias select find_all
+
+  ##
+  # Return a sorted array of all elements
+  # which are yield by `each`. If no block
+  # is given <=> will be invoked on each
+  # element to define the order. Otherwise
+  # the given block will be used for
+  # sorting.
+  #
+  # ISO 15.3.2.2.19
+  def sort(&block)
+    self.map {|*val| val.__svalue}.sort(&block)
+  end
+
+  ##
+  # Alias for entries.
+  #
+  # ISO 15.3.2.2.20
+  alias to_a entries
+
+  # redefine #hash 15.3.1.3.15
+  def hash
+    if __method_recursive?(:hash)
+      # Recursion detected, return a fixed value to break the loop
+      return 0
+    end
+
+    h = 12347
+    i = 0
+    self.each do |e|
+      h = __update_hash(h, i, e.hash)
+      i += 1
+    end
+    h
+  end
+end

data/ext/enclave/mruby/mrblib/hash.rb

@@ -0,0 +1,276 @@
+##
+# Hash
+#
+# ISO 15.2.13
+class Hash
+  ##
+  # Hash is enumerable
+  #
+  # ISO 15.2.13.3
+  include Enumerable
+
+
+
+  ##
+  # call-seq:
+  #   hash.delete(key) -> value or nil
+  #   hash.delete(key) {|key| ... } -> object
+  #
+  # Delete the element with the key `key`.
+  # Return the value of the element if `key`
+  # was found. Return nil if nothing was
+  # found. If a block is given, call the
+  # block with the value of the element.
+  #
+  # ISO 15.2.13.4.8
+  def delete(key, &block)
+    if block && !self.has_key?(key)
+      return block.call(key)
+    end
+    self.__delete(key)
+  end
+
+  ##
+  # call-seq:
+  #   hsh.each      {| key, value | block } -> hsh
+  #   hsh.each_pair {| key, value | block } -> hsh
+  #   hsh.each                              -> an_enumerator
+  #   hsh.each_pair                         -> an_enumerator
+  #
+  # Calls the given block for each element of `self`
+  # and pass the key and value of each element.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.each {|key, value| puts "#{key} is #{value}" }
+  #
+  # <em>produces:</em>
+  #
+  # a is 100
+  # b is 200
+  #
+  # ISO 15.2.13.4.9
+  def each(&block)
+    return to_enum(:each) unless block
+
+    keys = self.keys
+    vals = self.values
+    len = self.size
+    i = 0
+    while i < len
+      block.call([keys[i], vals[i]])
+      i += 1
+    end
+    self
+  end
+
+  ##
+  # call-seq:
+  #   hsh.each_key {| key | block } -> hsh
+  #   hsh.each_key                  -> an_enumerator
+  #
+  # Calls the given block for each element of `self`
+  # and pass the key of each element.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #   h = { "a" => 100, "b" => 200 }
+  #   h.each_key {|key| puts key }
+  #
+  # <em>produces:</em>
+  #
+  #  a
+  #  b
+  #
+  # ISO 15.2.13.4.10
+  def each_key(&block)
+    return to_enum(:each_key) unless block
+
+    self.keys.each {|k| block.call(k)}
+    self
+  end
+
+  ##
+  # call-seq:
+  #   hsh.each_value {| value | block } -> self
+  #   hsh.each_value                    -> an_enumerator
+  #
+  # Calls the given block with each value; returns `self`:
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #  h = { "a" => 100, "b" => 200 }
+  #  h.each_value {|value| puts value }
+  #
+  # <em>produces:</em>
+  #
+  #  100
+  #  200
+  #
+  # ISO 15.2.13.4.11
+  def each_value(&block)
+    return to_enum(:each_value) unless block
+
+    self.values.each {|v| block.call(v)}
+    self
+  end
+
+  ##
+  # call-seq:
+  #     hsh.merge(other_hash..)                                 -> hsh
+  #     hsh.merge(other_hash..){|key, oldval, newval| block}    -> hsh
+  #
+  #  Returns the new \Hash formed by merging each of `other_hashes`
+  #  into a copy of `self`.
+  #
+  #  Each argument in `other_hashes` must be a \Hash.
+  #  Adds the contents of _other_hash_ to _hsh_. If no block is specified,
+  #  entries with duplicate keys are overwritten with the values from
+  #  _other_hash_, otherwise the value of each duplicate key is determined by
+  #  calling the block with the key, its value in _hsh_ and its value in
+  #  _other_hash_.
+  #
+  #  Example:
+  #   h = {foo: 0, bar: 1, baz: 2}
+  #   h1 = {bat: 3, bar: 4}
+  #   h2 = {bam: 5, bat:6}
+  #   h3 = h.merge(h1, h2) { |key, old_value, new_value| old_value + new_value }
+  #   h3 # => {:foo=>0, :bar=>5, :baz=>2, :bat=>9, :bam=>5}
+  #
+  # ISO 15.2.13.4.22
+  def merge(*others, &block)
+    h = self.dup
+    return h.__merge(*others) unless block
+    i=0; len=others.size
+    while i<len
+      other = others[i]
+      i += 1
+      raise TypeError, "Hash required (#{other.class} given)" unless Hash === other
+      other.each_key {|k|
+        h[k] = (self.has_key?(k))? block.call(k, self[k], other[k]): other[k]
+      }
+    end
+    h
+  end
+
+  ##
+  #  call-seq:
+  #     hsh.reject! {| key, value | block }  -> hsh or nil
+  #     hsh.reject!                          -> an_enumerator
+  #
+  #  Equivalent to `Hash#delete_if`, but returns
+  #  `nil` if no changes were made.
+  #
+  #  1.8/1.9 Hash#reject! returns Hash; ISO says nothing.
+  #
+  def reject!(&block)
+    return to_enum(:reject!) unless block
+
+    keys = []
+    self.each {|k,v|
+      if block.call([k, v])
+        keys.push(k)
+      end
+    }
+    return nil if keys.size == 0
+    keys.each {|k|
+      self.delete(k)
+    }
+    self
+  end
+
+  ##
+  #  call-seq:
+  #     hsh.reject {|key, value| block}   -> a_hash
+  #     hsh.reject                        -> an_enumerator
+  #
+  #  Returns a new hash consisting of entries for which the block returns false.
+  #
+  #  If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300 }
+  #     h.reject {|k,v| k < "b"}  #=> {"b" => 200, "c" => 300}
+  #     h.reject {|k,v| v > 100}  #=> {"a" => 100}
+  #
+  #  1.8/1.9 Hash#reject returns Hash; ISO says nothing.
+  #
+  def reject(&block)
+    return to_enum(:reject) unless block
+
+    h = {}
+    self.each {|k,v|
+      unless block.call([k, v])
+        h[k] = v
+      end
+    }
+    h
+  end
+
+  ##
+  #  call-seq:
+  #     hsh.select! {| key, value | block }  -> hsh or nil
+  #     hsh.select!                          -> an_enumerator
+  #
+  #  Equivalent to `Hash#keep_if`, but returns
+  #  `nil` if no changes were made.
+  #
+  #  1.9 Hash#select! returns Hash; ISO says nothing.
+  #
+  def select!(&block)
+    return to_enum(:select!) unless block
+
+    keys = []
+    self.each {|k,v|
+      unless block.call([k, v])
+        keys.push(k)
+      end
+    }
+    return nil if keys.size == 0
+    keys.each {|k|
+      self.delete(k)
+    }
+    self
+  end
+
+  ##
+  #  call-seq:
+  #     hsh.select {|key, value| block}   -> a_hash
+  #     hsh.select                        -> an_enumerator
+  #
+  #  Returns a new hash consisting of entries for which the block returns true.
+  #
+  #  If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300 }
+  #     h.select {|k,v| k > "a"}  #=> {"b" => 200, "c" => 300}
+  #     h.select {|k,v| v < 200}  #=> {"a" => 100}
+  #
+  #  1.9 Hash#select returns Hash; ISO says nothing
+  #
+  def select(&block)
+    return to_enum(:select) unless block
+
+    h = {}
+    self.each {|k,v|
+      if block.call([k, v])
+        h[k] = v
+      end
+    }
+    h
+  end
+
+  ##
+  # call-seq:
+  #   hash.deconstruct_keys(keys) -> hash
+  #
+  # Returns +self+. This method is called by pattern matching to
+  # deconstruct the hash for matching.
+  #
+  # The +keys+ argument is an array of keys the pattern expects,
+  # or +nil+ for exact matching (when +**nil+ is used).
+  #
+  def deconstruct_keys(_keys)
+    self
+  end
+end