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)
