def update(n): o = OrderedDict() o[3] = 4 v = OrderedDict() v[n] = 5 o.update(v) return o[3]
def delitem(n): o = OrderedDict() o[2] = 3 o[3] = 4 del o[n] vals = o.values() return vals[0] * 10 + len(vals)
def delitem(n): o = OrderedDict() o[2] = 3 o[3] = 4 del o[n] vals = o.values() return vals[0] * 10 + len(vals)
def pop_keyerror(n): o = OrderedDict() o[3] = 4 try: return o.pop(n) except KeyError: return 500
def pop_keyerror(n): o = OrderedDict() o[3] = 4 try: return o.pop(n) except KeyError: return 500
def update(n): o = OrderedDict() o[3] = 4 v = OrderedDict() v[n] = 5 o.update(v) return o[3]
def merge_dicts(n): if n: o = OrderedDict() o[5] = 10 else: o = OrderedDict() o[2] = 20 o[3] = 30 return o[3]
def iteritems(n): o = OrderedDict() o[0] = 10 o[2] = 15 o[3] = 12 r = [] for k, v in o.iteritems(): r.append((k, v)) p = r[n] return p[0] * 100 + p[1]
def iteritems(n): o = OrderedDict() o[0] = 10 o[2] = 15 o[3] = 12 r = [] for k, v in o.iteritems(): r.append((k, v)) p = r[n] return p[0] * 100 + p[1]
def popitem(n): o = OrderedDict() if n: o[n] = n try: key, val = o.popitem() except KeyError: return 400 else: return key * 10 + val
def popitem(n): o = OrderedDict() if n: o[n] = n try: key, val = o.popitem() except KeyError: return 400 else: return key * 10 + val
def f(n): d = OrderedDict() while n > 0: jd.jit_merge_point() if n % 10 == 0: n -= len(d) d = OrderedDict() d["a"] = n n -= 1 return len(d)
def __init__(self, space, klass=None): W_Object.__init__(self, space, klass) self.contents = OrderedDict(space.eq_w, space.hash_w) self.w_default = space.w_nil self.default_proc = None
def get_empty_storage(self, space): return self.erase(OrderedDict(space.eq_w, space.hash_w))
def custom_eq_hash(n): o = OrderedDict(Simple.eq, Simple.hash) o[Simple(n)] = 23 return o[Simple(n)]
def get(n): o = OrderedDict() o[4] = 3 return o.get(n, 123)
def pop(n): o = OrderedDict() o[1] = 12 o[2] = 3 return (o.pop(n) * 10) + len(o)
def get(n): o = OrderedDict() o[4] = 3 return o.get(n, 123)
def values(n): o = OrderedDict() o[4] = 1 o[5] = 2 o[4] = 3 return o.values()[n]
def copy(n): o = OrderedDict(Simple.eq, Simple.hash) o[Simple(n)] = n d = o.copy() return d.values()[0] * 10 + len(d)
def clear(): o = OrderedDict() o[3] = 4 o.clear() return len(o)
def keys(n): o = OrderedDict() o[4] = 1 o[5] = 2 o[4] = 2 return o.keys()[n]
def values(n): o = OrderedDict() o[4] = 1 o[5] = 2 o[4] = 3 return o.values()[n]
def pop_default(n, d): o = OrderedDict() o[1] = 12 o[2] = 3 return (o.pop(n, d) * 10) + len(o)
def grow(n): o = OrderedDict() for i in xrange(n): o[i] = -20 return o[3]
def iteritems_next_method(n): o = OrderedDict() o[n] = 5 it = o.iteritems() return it.next()[1]
def keys(n): o = OrderedDict() o[4] = 1 o[5] = 2 o[4] = 2 return o.keys()[n]
def pop(n): o = OrderedDict() o[1] = 12 o[2] = 3 return (o.pop(n) * 10) + len(o)
def keys_object(n): o = OrderedDict() o[Simple(1)] = None o[Simple(2)] = None o[Simple(3)] = None return o.keys()[n].x
class W_HashObject(W_Object): classdef = ClassDef("Hash", W_Object.classdef) classdef.include_module(Enumerable) def __init__(self, space, klass=None): W_Object.__init__(self, space, klass) self.contents = OrderedDict(space.eq_w, space.hash_w) self.w_default = space.w_nil self.default_proc = None @classdef.singleton_method("allocate") def method_allocate(self, space): return W_HashObject(space, self) @classdef.singleton_method("try_convert") def method_try_convert(self, space, w_obj): if not space.is_kind_of(w_obj, space.w_hash): w_obj = space.convert_type(w_obj, space.w_hash, "to_hash", raise_error=False) return w_obj @classdef.method("initialize") def method_initialize(self, space, w_default=None, block=None): if w_default is not None: self.w_default = w_default if block is not None: self.default_proc = block @classdef.method("default") def method_default(self, space, w_key=None): if self.default_proc is not None and w_key is not None: return space.invoke_block(self.default_proc, [self, w_key]) else: return self.w_default @classdef.method("default=") @check_frozen() def method_set_default(self, space, w_defl): self.default_proc = None self.w_default = w_defl @classdef.method("default_proc") def method_default_proc(self, space): if self.default_proc is None: return space.w_nil return self.default_proc @classdef.method("default_proc=") def method_set_default_proc(self, space, w_proc): w_new_proc = space.convert_type(w_proc, space.w_proc, "to_proc") assert isinstance(w_new_proc, W_ProcObject) arity = space.int_w(space.send(w_new_proc, "arity")) if arity != 2 and space.is_true(space.send(w_new_proc, "lambda?")): raise space.error( space.w_TypeError, "default_proc takes two arguments (2 for %s)" % arity) self.default_proc = w_new_proc self.w_default = space.w_nil return w_proc @classdef.method("[]") def method_subscript(self, space, w_key): try: return self.contents[w_key] except KeyError: return space.send(self, "default", [w_key]) @classdef.method("fetch") def method_fetch(self, space, w_key, w_value=None, block=None): try: return self.contents[w_key] except KeyError: if block is not None: return space.invoke_block(block, [w_key]) elif w_value is not None: return w_value else: raise space.error( space.w_KeyError, "key not found: %s" % space.send(w_key, "inspect")) @classdef.method("store") @classdef.method("[]=") @check_frozen() def method_subscript_assign(self, space, w_key, w_value): if (space.is_kind_of(w_key, space.w_string) and not space.is_true(space.send(w_key, "frozen?"))): w_key = space.send(w_key, "dup") w_key = space.send(w_key, "freeze") self.contents[w_key] = w_value return w_value @classdef.method("length") @classdef.method("size") def method_size(self, space): return space.newint(len(self.contents)) @classdef.method("empty?") def method_emptyp(self, space): return space.newbool(not bool(self.contents)) @classdef.method("delete") @check_frozen() def method_delete(self, space, w_key, block): w_res = self.contents.pop(w_key, None) if w_res is None: if block: return space.invoke_block(block, [w_key]) w_res = space.w_nil return w_res @classdef.method("clear") @check_frozen() def method_clear(self, space): self.contents.clear() return self @classdef.method("shift") @check_frozen() def method_shift(self, space): if not self.contents: return space.send(self, "default", [space.w_nil]) w_key, w_value = self.contents.popitem() return space.newarray([w_key, w_value]) @classdef.method("initialize_copy") @classdef.method("replace") @check_frozen() def method_replace(self, space, w_hash): w_hash = space.convert_type(w_hash, space.w_hash, "to_hash") assert isinstance(w_hash, W_HashObject) self.contents.clear() self.contents.update(w_hash.contents) self.w_default = w_hash.w_default self.default_proc = w_hash.default_proc return self @classdef.method("keys") def method_keys(self, space): return space.newarray(self.contents.keys()) @classdef.method("values") def method_values(self, space): return space.newarray(self.contents.values()) @classdef.method("to_hash") def method_to_hash(self, space): return self @classdef.method("key?") @classdef.method("has_key?") @classdef.method("member?") @classdef.method("include?") def method_includep(self, space, w_key): return space.newbool(w_key in self.contents)
def clear(): o = OrderedDict() o[3] = 4 o.clear() return len(o)
def iteritems_next_method(n): o = OrderedDict() o[n] = 5 it = o.iteritems() return it.next()[1]
def contains(n): o = OrderedDict() o[4] = 5 return n in o
def simple_get_set(): o = OrderedDict() o["a"] = 2 return o["a"]
def pop_default(n, d): o = OrderedDict() o[1] = 12 o[2] = 3 return (o.pop(n, d) * 10) + len(o)
def copy(n): o = OrderedDict(Simple.eq, Simple.hash) o[Simple(n)] = n d = o.copy() return d.values()[0] * 10 + len(d)
class W_HashObject(W_Object): classdef = ClassDef("Hash", W_Object.classdef, filepath=__file__) classdef.include_module(Enumerable) def __init__(self, space, klass=None): W_Object.__init__(self, space, klass) self.contents = OrderedDict(space.eq_w, space.hash_w) self.w_default = space.w_nil self.default_proc = None @classdef.singleton_method("allocate") def method_allocate(self, space, args_w): return W_HashObject(space, self) @classdef.singleton_method("try_convert") def method_try_convert(self, space, w_obj): if not space.is_kind_of(w_obj, space.w_hash): w_obj = space.convert_type(w_obj, space.w_hash, "to_hash", raise_error=False) return w_obj @classdef.method("initialize") def method_initialize(self, space, w_default=None, block=None): if w_default is not None: self.w_default = w_default if block is not None: self.default_proc = block @classdef.method("default") def method_default(self, space, w_key=None): if self.default_proc is not None and w_key is not None: return space.invoke_block(self.default_proc, [self, w_key]) else: return self.w_default @classdef.method("default=") @check_frozen() def method_set_default(self, space, w_defl): self.default_proc = None self.w_default = w_defl @classdef.method("default_proc") def method_default_proc(self, space): if self.default_proc is None: return space.w_nil return space.newproc(self.default_proc) @classdef.method("[]") def method_subscript(self, space, w_key): try: return self.contents[w_key] except KeyError: return space.send(self, space.newsymbol("default"), [w_key]) @classdef.method("fetch") def method_fetch(self, space, w_key, w_value=None, block=None): try: return self.contents[w_key] except KeyError: if w_value is not None: return w_value elif block is not None: return space.invoke_block(block, [w_key]) else: raise space.error(space.w_KeyError, "key not found: %s" % space.send(w_key, space.newsymbol("inspect"))) @classdef.method("store") @classdef.method("[]=") @check_frozen() def method_subscript_assign(self, space, w_key, w_value): if space.is_kind_of(w_key, space.w_string) and not space.is_true(space.send(w_key, space.newsymbol("frozen?"))): w_key = space.send(w_key, space.newsymbol("dup")) w_key = space.send(w_key, space.newsymbol("freeze")) self.contents[w_key] = w_value return w_value @classdef.method("length") @classdef.method("size") def method_size(self, space): return space.newint(len(self.contents)) @classdef.method("empty?") def method_emptyp(self, space): return space.newbool(not bool(self.contents)) @classdef.method("delete") @check_frozen() def method_delete(self, space, w_key, block): w_res = self.contents.pop(w_key, None) if w_res is None: if block: return space.invoke_block(block, [w_key]) w_res = space.w_nil return w_res @classdef.method("clear") @check_frozen() def method_clear(self, space): self.contents.clear() return self @classdef.method("shift") @check_frozen() def method_shift(self, space): if not self.contents: return space.send(self, space.newsymbol("default"), [space.w_nil]) w_key, w_value = self.contents.popitem() return space.newarray([w_key, w_value]) @classdef.method("initialize_copy") @classdef.method("replace") @check_frozen() def method_replace(self, space, w_hash): assert isinstance(w_hash, W_HashObject) self.contents.clear() self.contents.update(w_hash.contents) return self @classdef.method("keys") def method_keys(self, space): return space.newarray(self.contents.keys()) @classdef.method("values") def method_values(self, space): return space.newarray(self.contents.values()) @classdef.method("to_hash") def method_to_hash(self, space): return self @classdef.method("key?") @classdef.method("has_key?") @classdef.method("member?") @classdef.method("include?") def method_includep(self, space, w_key): return space.newbool(w_key in self.contents)
def keys_object(n): o = OrderedDict() o[Simple(1)] = None o[Simple(2)] = None o[Simple(3)] = None return o.keys()[n].x
def truthy(n): o = OrderedDict() if n: o[n] = n return bool(o)
class Glob(object): def __init__(self, cache, matches=None): self.cache = cache self._matches = OrderedDict() for match in (matches or []): self.append_match(match) def matches(self): return self._matches.keys() def append_match(self, match): self._matches[match] = None def is_constant(self, part, flags): special_chars = "?*[" if not (flags & FNM_NOESCAPE): special_chars += "\\" for ch in part: if ch in special_chars: return False return True def single_compile(self, glob, flags=0): parts = path_split(glob) if parts[-1] == "/": last = DirectoriesOnly(None, flags) else: file = parts.pop() if self.is_constant(file, flags): last = ConstantEntry(None, flags, file) else: last = EntryMatch(None, flags, file) while parts: sep_parts = [] while parts and parts[-1] == "/": sep_parts.append(parts.pop()) last.separator = "".join(sep_parts) if not parts: last = RootDirectory(last, flags) else: dir = parts.pop() if dir == "**": if parts: last = RecursiveDirectories(last, flags) else: last = StartRecursiveDirectories(last, flags) elif self.is_constant(dir, flags): last = ConstantDirectory(last, flags, dir) else: last = DirectoryMatch(last, flags, dir) return last def run(self, node): node.call(self, None) def glob(self, pattern, flags): if "{" in pattern: patterns = self.compile(pattern, flags) for node in patterns: self.run(node) else: node = self.single_compile(pattern, flags) if node: self.run(node) def process_braces(self, pattern, flags, i=0): should_escape = flags & FNM_NOESCAPE == 0 patterns = [] escaped = False pattern_start = i segments = [""] while i < len(pattern): ch = pattern[i] if ch == "\\" and should_escape and not escaped: escaped = True elif ch == ",": if escaped: escaped = False else: suffix = pattern[pattern_start:i] patterns.extend(combine_segments(segments, suffix)) segments = [""] pattern_start = i + 1 elif ch == "}": if escaped: escaped = False else: suffix = pattern[pattern_start:i] patterns.extend(combine_segments(segments, suffix)) return i, patterns elif ch == "{": if escaped: escaped = False else: suffix = pattern[pattern_start:i] i, new_segs = self.process_braces(pattern, flags, i + 1) segments = combine_segments(segments, suffix, new_segs) pattern_start = i + 1 else: escaped = False i += 1 suffix = pattern[pattern_start:] patterns.extend(combine_segments(segments, suffix)) return i, patterns def compile(self, pattern, flags=0): i, patterns = self.process_braces(pattern, flags) return [self.single_compile(p) for p in patterns]
def create(): OrderedDict() return 0
def __init__(self, cache, matches=None): self.cache = cache self._matches = OrderedDict() for match in (matches or []): self.append_match(match)
def get_set_object(n): x = Simple(n) o = OrderedDict() o[x] = x return o[x].x
class Glob(object): def __init__(self, cache, matches=None): self.cache = cache self._matches = OrderedDict() for match in (matches or []): self.append_match(match) def matches(self): return self._matches.keys() def append_match(self, match): self._matches[match] = None def is_constant(self, part, flags): special_chars = "?*[" if not (flags & FNM_NOESCAPE): special_chars += "\\" for ch in part: if ch in special_chars: return False return True def single_compile(self, glob, flags=0): parts = path_split(glob) if parts[-1] == "/": last = DirectoriesOnly(None, flags) else: file = parts.pop() if self.is_constant(file, flags): last = ConstantEntry(None, flags, file) else: last = EntryMatch(None, flags, file) while parts: sep_parts = [] while parts and parts[-1] == "/": sep_parts.append(parts.pop()) last.separator = "".join(sep_parts) if not parts: last = RootDirectory(last, flags) else: dir = parts.pop() if dir == "**": if parts: last = RecursiveDirectories(last, flags) else: last = StartRecursiveDirectories(last, flags) elif self.is_constant(dir, flags): last = ConstantDirectory(last, flags, dir) else: last = DirectoryMatch(last, flags, dir) return last def run(self, node): node.call(self, None) def glob(self, pattern, flags): if "{" in pattern: patterns = self.compile(pattern, flags) for node in patterns: self.run(node) else: node = self.single_compile(pattern, flags) if node: self.run(node) def process_braces(self, pattern, flags, i=0): should_escape = flags & FNM_NOESCAPE == 0 patterns = [] escaped = False pattern_start = i segments = [""] while i < len(pattern): ch = pattern[i] if ch == "\\" and should_escape and not escaped: escaped = True elif ch == ",": if escaped: escaped = False else: suffix = pattern[pattern_start:i] patterns.extend(combine_segments(segments, suffix)) segments = [""] pattern_start = i + 1 elif ch == "}": if escaped: escaped = False else: suffix = pattern[pattern_start:i] patterns.extend(combine_segments(segments, suffix)) return i, patterns elif ch == "{": if escaped: escaped = False else: suffix = pattern[pattern_start:i] i, new_segs = self.process_braces(pattern, flags, i + 1) segments = combine_segments(segments, suffix, new_segs) pattern_start = i + 1 else: escaped = False i += 1 suffix = pattern[pattern_start:] patterns.extend(combine_segments(segments, suffix)) return i, patterns def compile(self, pattern, flags=0): i, patterns = self.process_braces(pattern, flags) return [self.single_compile(p) for p in patterns]
def len(n): o = OrderedDict() for i in xrange(n): o[i] = i return len(o)
def __init__(self, cache, matches=None): self.cache = cache self._matches = OrderedDict() for match in (matches or []): self.append_match(match)
def __init__(self, space, klass=None): W_Object.__init__(self, space, klass) self.contents = OrderedDict(space.eq_w, space.hash_w) self.w_default = space.w_nil self.default_proc = None
class W_HashObject(W_Object): classdef = ClassDef("Hash", W_Object.classdef, filepath=__file__) classdef.include_module(Enumerable) def __init__(self, space, klass=None): W_Object.__init__(self, space, klass) self.contents = OrderedDict(space.eq_w, space.hash_w) self.w_default = space.w_nil self.default_proc = None @classdef.singleton_method("allocate") def method_allocate(self, space, args_w): return W_HashObject(space, self) @classdef.singleton_method("[]") def singleton_method_subscript(self, space, w_obj=None): if w_obj is None: return W_HashObject(space) w_res = space.convert_type(w_obj, space.w_hash, "to_hash", raise_error=False) if w_res is space.w_nil: raise NotImplementedError assert isinstance(w_res, W_HashObject) result = W_HashObject(space) result.contents.update(w_res.contents) return result @classdef.method("initialize") def method_initialize(self, space, w_default=None, block=None): if w_default is not None: self.w_default = w_default if block is not None: self.default_proc = block @classdef.method("default") def method_default(self, space, w_key=None): if self.default_proc is not None: return space.invoke_block(self.default_proc, [self, w_key]) else: return self.w_default @classdef.method("[]") def method_subscript(self, space, w_key): try: return self.contents[w_key] except KeyError: return space.send(self, space.newsymbol("default"), [w_key]) @classdef.method("fetch") def method_fetch(self, space, w_key, w_value=None, block=None): try: return self.contents[w_key] except KeyError: if w_value is not None: return w_value elif block is not None: return space.invoke_block(block, [w_key]) else: raise space.error(space.w_KeyError, "key not found: %s" % space.send(w_key, space.newsymbol("inspect"))) @classdef.method("store") @classdef.method("[]=") def method_subscript_assign(self, w_key, w_value): self.contents[w_key] = w_value return w_value @classdef.method("length") @classdef.method("size") def method_size(self, space): return space.newint(len(self.contents)) @classdef.method("empty?") def method_emptyp(self, space): return space.newbool(not bool(self.contents)) @classdef.method("delete") @check_frozen() def method_delete(self, space, w_key, block): w_res = self.contents.pop(w_key, None) if w_res is None: if block: return space.invoke_block(block, [w_key]) w_res = space.w_nil return w_res @classdef.method("clear") @check_frozen() def method_clear(self, space): self.contents.clear() return self @classdef.method("shift") @check_frozen() def method_shift(self, space): if not self.contents: return space.send(self, space.newsymbol("default")) w_key, w_value = self.contents.popitem() return space.newarray([w_key, w_value]) @classdef.method("initialize_copy") @classdef.method("replace") @check_frozen() def method_replace(self, space, w_hash): assert isinstance(w_hash, W_HashObject) self.contents.clear() self.contents.update(w_hash.contents) return self @classdef.method("keys") def method_keys(self, space): return space.newarray(self.contents.keys()) @classdef.method("values") def method_values(self, space): return space.newarray(self.contents.values()) @classdef.method("to_hash") def method_to_hash(self, space): return self classdef.app_method(""" def each iter = Topaz::HashIterator.new(self) while true begin key, value = iter.next() rescue StopIteration return end yield key, value end end alias each_pair each def each_key each { |k, v| yield k } end """) @classdef.method("key?") @classdef.method("has_key?") @classdef.method("member?") @classdef.method("include?") def method_includep(self, space, w_key): return space.newbool(w_key in self.contents) classdef.app_method(""" def ==(other) if self.equal?(other) return true end if !other.kind_of?(Hash) return false end if self.size != other.size return false end self.each do |key, value| if !other.has_key?(key) || other[key] != value return false end end return true end """)
def get_empty_storage(self, space): return self.erase(OrderedDict())
class W_HashObject(W_Object): classdef = ClassDef("Hash", W_Object.classdef) classdef.include_module(Enumerable) def __init__(self, space, klass=None): W_Object.__init__(self, space, klass) self.contents = OrderedDict(space.eq_w, space.hash_w) self.w_default = space.w_nil self.default_proc = None @classdef.singleton_method("allocate") def method_allocate(self, space): return W_HashObject(space, self) @classdef.method("initialize") @check_frozen() def method_initialize(self, space, w_default=None, block=None): if w_default is not None: if block is not None: raise space.error(space.w_ArgumentError, "wrong number of arguments") self.w_default = w_default if block is not None: self.default_proc = block return self @classdef.method("default") def method_default(self, space, w_key=None): if self.default_proc is not None and w_key is not None: return space.invoke_block(self.default_proc, [self, w_key]) else: return self.w_default @classdef.method("default=") @check_frozen() def method_set_default(self, space, w_defl): self.default_proc = None self.w_default = w_defl @classdef.method("default_proc") def method_default_proc(self, space): if self.default_proc is None: return space.w_nil return self.default_proc @classdef.method("default_proc=") def method_set_default_proc(self, space, w_proc): w_new_proc = space.convert_type(w_proc, space.w_proc, "to_proc") assert isinstance(w_new_proc, W_ProcObject) arity = space.int_w(space.send(w_new_proc, "arity")) if arity != 2 and space.is_true(space.send(w_new_proc, "lambda?")): raise space.error(space.w_TypeError, "default_proc takes two arguments (2 for %s)" % arity) self.default_proc = w_new_proc self.w_default = space.w_nil return w_proc @classdef.method("[]") def method_subscript(self, space, w_key): try: return self.contents[w_key] except KeyError: return space.send(self, "default", [w_key]) @classdef.method("fetch") def method_fetch(self, space, w_key, w_value=None, block=None): try: return self.contents[w_key] except KeyError: if block is not None: return space.invoke_block(block, [w_key]) elif w_value is not None: return w_value else: raise space.error(space.w_KeyError, "key not found: %s" % space.send(w_key, "inspect")) @classdef.method("store") @classdef.method("[]=") @check_frozen() def method_subscript_assign(self, space, w_key, w_value): if space.is_kind_of(w_key, space.w_string) and not space.is_true(space.send(w_key, "frozen?")): w_key = space.send(w_key, "dup") w_key = space.send(w_key, "freeze") self.contents[w_key] = w_value return w_value @classdef.method("length") @classdef.method("size") def method_size(self, space): return space.newint(len(self.contents)) @classdef.method("empty?") def method_emptyp(self, space): return space.newbool(not bool(self.contents)) @classdef.method("delete") @check_frozen() def method_delete(self, space, w_key, block): w_res = self.contents.pop(w_key, None) if w_res is None: if block: return space.invoke_block(block, [w_key]) w_res = space.w_nil return w_res @classdef.method("clear") @check_frozen() def method_clear(self, space): self.contents.clear() return self @classdef.method("shift") @check_frozen() def method_shift(self, space): if not self.contents: return space.send(self, "default", [space.w_nil]) w_key, w_value = self.contents.popitem() return space.newarray([w_key, w_value]) @classdef.method("initialize_copy") @classdef.method("replace") @check_frozen() def method_replace(self, space, w_hash): w_hash = space.convert_type(w_hash, space.w_hash, "to_hash") assert isinstance(w_hash, W_HashObject) self.contents.clear() self.contents.update(w_hash.contents) self.w_default = w_hash.w_default self.default_proc = w_hash.default_proc return self @classdef.method("keys") def method_keys(self, space): return space.newarray(self.contents.keys()) @classdef.method("values") def method_values(self, space): return space.newarray(self.contents.values()) @classdef.method("to_hash") def method_to_hash(self, space): return self @classdef.method("key?") @classdef.method("has_key?") @classdef.method("member?") @classdef.method("include?") def method_includep(self, space, w_key): return space.newbool(w_key in self.contents)