initial inject repository.

objcode · objcode · commit ece2f963766a · 2011-10-26T22:26:45.000-07:00
diff --git a/README.md b/README.md
@@ -0,0 +1,30 @@
+#Inject python locals#
+
+
+A bit of hackery to experiment with alternative call flow in python.
+
+To use:
+
+   def foo():
+       print a
+       
+   inject(a=5).into(foo)
+   >> 5
+
+   @inject(cat='man')
+   def bar():
+       print "the cat is a", cat
+
+   bar()
+   >> the cat is a man
+
+
+**Q:  Why should I use this?**
+A: You shouldn't
+
+**Q: Why does it exist?**
+A: Because it can
+
+**Q: Are you crazy?**
+A: ?
+
diff --git a/inject.py b/inject.py
@@ -0,0 +1,33 @@
+
+import sys
+
+class inject(object):
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+
+    def __call__(self, fn):
+        from functools import wraps
+        @wraps(fn)
+        def wrapped(*args, **kwargs):
+            print "doing wrap", args, kwargs
+            old_trace = sys.gettrace()
+            def tracefn(frame, event, arg):
+                # define a new tracefn each time, since it needs to
+                # call the *current* tracefn if they're in debug mode
+                print 'updating locals with', self.kwargs
+                frame.f_locals.update(self.kwargs)
+                if old_trace:
+                    return old_trace(frame, event, arg)
+                else:
+                    return None
+
+            sys.settrace(tracefn)
+            retval = fn(*args, **kwargs)
+            sys.settrace(old_trace)
+            return retval
+
+        return wrapped
+
+    def into(self, fn, *args, **kwargs):
+        return self(fn)(*args, **kwargs)
+            
diff --git a/test_inject.py b/test_inject.py
@@ -0,0 +1,43 @@
+
+from inject import inject
+
+@inject(a=5)
+def test_inject():
+    print locals()
+    assert locals() == {'a': 5}
+
+@inject(cat='foo', whatever=15)
+def test_inject2():
+    print locals()
+    assert locals() == {'cat': 'foo', 'whatever': 15}
+
+def test_inject_keeps_old_trace_behavior():
+    import sys
+    events = []
+    def tracefn(frame, event, arg):
+        # only grab the events for our function
+        if frame.f_code.co_name == 'foo':
+            events.append(event)
+        return tracefn
+
+    @inject(a=5)
+    def foo():
+        assert locals() == {'a': 5}
+
+    # be a good citizen and reset our tracefn
+    old_trace = sys.gettrace()
+    sys.settrace(tracefn)
+    foo()
+    assert sys.gettrace() == tracefn
+    sys.settrace(old_trace)
+    assert events == ['call', 'line', 'return']
+
+
+def test_inject_apply():
+
+    def foo():
+        return locals()
+
+    assert inject(a=5).into(foo) == {'a': 5}
+    
+    
