From d12df0d360fe0dabdca3591654327834bee2803b Mon Sep 17 00:00:00 2001
From: Misko Hevery
Date: Tue, 25 Oct 2011 22:21:21 -0700
Subject: refactor(compiler) turn compiler into a service

BREAK
- remove angular.compile() since the compile method is now a service and needs to be injected
---
 test/AngularSpec.js          |  22 +++---
 test/BinderSpec.js           | 146 ++++++++++++++++++-------------------
 test/ResourceSpec.js         |   8 +--
 test/ScenarioSpec.js         |  12 ++--
 test/directivesSpec.js       | 168 +++++++++++++++++++++----------------------
 test/markupSpec.js           |  88 +++++++++++------------
 test/service/compilerSpec.js | 140 ++++++++++++++++++------------------
 test/testabilityPatch.js     |   1 -
 test/widget/formSpec.js      |  24 +++----
 test/widget/inputSpec.js     |  30 ++++----
 test/widget/selectSpec.js    |   4 +-
 test/widgetsSpec.js          | 140 ++++++++++++++++++------------------
 12 files changed, 392 insertions(+), 391 deletions(-)

(limited to 'test')

diff --git a/test/AngularSpec.js b/test/AngularSpec.js
index eb64a825..7e6f35fa 100644
--- a/test/AngularSpec.js
+++ b/test/AngularSpec.js
@@ -423,7 +423,7 @@ describe('angular', function() {
 
 
   describe('directive', function() {
-    it('should register directives with case-insensitive id', function() {
+    it('should register directives with case-insensitive id', inject(function($compile) {
       angularDirective('ALLCAPS', function(val, el) {el.text('+' + val + '+')});
       angularDirective('lowercase', function(val, el) {el.text('-' + val + '-')});
 
@@ -433,14 +433,14 @@ describe('angular', function() {
                         '<span ALLCAPS="xx3"></span>' +
                         '<span lowerCASE="XX4">xx4</span>' +
                       '</div>');
-      compile(el);
+      $compile(el);
       expect(lowercase(sortedHtml(el))).toBe('<div>' +
                                                 '<span allcaps="xx1">+xx1+</span>' +
                                                 '<span allcaps="xx2">+xx2+</span>' +
                                                 '<span allcaps="xx3">+xx3+</span>' +
                                                 '<span lowercase="xx4">-xx4-</span>' +
                                               '</div>');
-    });
+    }));
   });
 
 
@@ -458,25 +458,25 @@ describe('angular', function() {
   });
 
   describe('compile', function() {
-    it('should link to existing node and create scope', inject(function($rootScope) {
+    it('should link to existing node and create scope', inject(function($rootScope, $compile) {
       var template = angular.element('<div>{{greeting = "hello world"}}</div>');
-      angular.compile(template)($rootScope);
+      $compile(template)($rootScope);
       $rootScope.$digest();
       expect(template.text()).toEqual('hello world');
       expect($rootScope.greeting).toEqual('hello world');
     }));
 
-    it('should link to existing node and given scope', inject(function($rootScope) {
+    it('should link to existing node and given scope', inject(function($rootScope, $compile) {
       var template = angular.element('<div>{{greeting = "hello world"}}</div>');
-      angular.compile(template)($rootScope);
+      $compile(template)($rootScope);
       $rootScope.$digest();
       expect(template.text()).toEqual('hello world');
     }));
 
-    it('should link to new node and given scope', inject(function($rootScope) {
+    it('should link to new node and given scope', inject(function($rootScope, $compile) {
       var template = jqLite('<div>{{greeting = "hello world"}}</div>');
 
-      var templateFn = angular.compile(template);
+      var templateFn = $compile(template);
       var templateClone = template.clone();
 
       var element = templateFn($rootScope, function(clone){
@@ -490,9 +490,9 @@ describe('angular', function() {
       expect($rootScope.greeting).toEqual('hello world');
     }));
 
-    it('should link to cloned node and create scope', inject(function($rootScope) {
+    it('should link to cloned node and create scope', inject(function($rootScope, $compile) {
       var template = jqLite('<div>{{greeting = "hello world"}}</div>');
-      var element = angular.compile(template)($rootScope, noop);
+      var element = $compile(template)($rootScope, noop);
       $rootScope.$digest();
       expect(template.text()).toEqual('');
       expect(element.text()).toEqual('hello world');
diff --git a/test/BinderSpec.js b/test/BinderSpec.js
index 8938bd13..6a459074 100644
--- a/test/BinderSpec.js
+++ b/test/BinderSpec.js
@@ -4,9 +4,9 @@ describe('Binder', function() {
   beforeEach(function() {
     this.compileToHtml = function (content) {
       var html;
-      inject(function($rootScope){
+      inject(function($rootScope, $compile){
         content = jqLite(content);
-        angular.compile(content)($rootScope);
+        $compile(content)($rootScope);
         html = sortedHtml(content);
       }).call(this);
       return html;
@@ -19,25 +19,25 @@ describe('Binder', function() {
     }
   });
 
-  it('BindUpdate', inject(function($rootScope) {
-    angular.compile('<div ng:init="a=123"/>')($rootScope);
+  it('BindUpdate', inject(function($rootScope, $compile) {
+    $compile('<div ng:init="a=123"/>')($rootScope);
     $rootScope.$digest();
     assertEquals(123, $rootScope.a);
   }));
 
-  it('ExecuteInitialization', inject(function($rootScope) {
-    angular.compile('<div ng:init="a=123">')($rootScope);
+  it('ExecuteInitialization', inject(function($rootScope, $compile) {
+    $compile('<div ng:init="a=123">')($rootScope);
     assertEquals($rootScope.a, 123);
   }));
 
-  it('ExecuteInitializationStatements', inject(function($rootScope) {
-    angular.compile('<div ng:init="a=123;b=345">')($rootScope);
+  it('ExecuteInitializationStatements', inject(function($rootScope, $compile) {
+    $compile('<div ng:init="a=123;b=345">')($rootScope);
     assertEquals($rootScope.a, 123);
     assertEquals($rootScope.b, 345);
   }));
 
-  it('ApplyTextBindings', inject(function($rootScope) {
-    var element = angular.compile('<div ng:bind="model.a">x</div>')($rootScope);
+  it('ApplyTextBindings', inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:bind="model.a">x</div>')($rootScope);
     $rootScope.model = {a:123};
     $rootScope.$apply();
     assertEquals('123', element.text());
@@ -51,7 +51,7 @@ describe('Binder', function() {
     assertEquals(this.compileToHtml("<b>{{b}}</b>"), '<b><span ng:bind="b"></span></b>');
   });
 
-  it('BindingSpaceConfusesIE', inject(function($rootScope) {
+  it('BindingSpaceConfusesIE', inject(function($rootScope, $compile) {
     if (!msie) return;
     var span = document.createElement("span");
     span.innerHTML = '&nbsp;';
@@ -65,44 +65,44 @@ describe('Binder', function() {
         this.compileToHtml("<b>{{A}} x {{B}} ({{C}})</b>"));
   }));
 
-  it('BindingOfAttributes', inject(function($rootScope) {
-    var element = angular.compile("<a href='http://s/a{{b}}c' foo='x'></a>")($rootScope);
+  it('BindingOfAttributes', inject(function($rootScope, $compile) {
+    var element = $compile("<a href='http://s/a{{b}}c' foo='x'></a>")($rootScope);
     var attrbinding = element.attr("ng:bind-attr");
     var bindings = fromJson(attrbinding);
     assertEquals("http://s/a{{b}}c", decodeURI(bindings.href));
     assertTrue(!bindings.foo);
   }));
 
-  it('MarkMultipleAttributes', inject(function($rootScope) {
-    var element = angular.compile('<a href="http://s/a{{b}}c" foo="{{d}}"></a>')($rootScope);
+  it('MarkMultipleAttributes', inject(function($rootScope, $compile) {
+    var element = $compile('<a href="http://s/a{{b}}c" foo="{{d}}"></a>')($rootScope);
     var attrbinding = element.attr("ng:bind-attr");
     var bindings = fromJson(attrbinding);
     assertEquals(bindings.foo, "{{d}}");
     assertEquals(decodeURI(bindings.href), "http://s/a{{b}}c");
   }));
 
-  it('AttributesNoneBound', inject(function($rootScope) {
-    var a = angular.compile("<a href='abc' foo='def'></a>")($rootScope);
+  it('AttributesNoneBound', inject(function($rootScope, $compile) {
+    var a = $compile("<a href='abc' foo='def'></a>")($rootScope);
     assertEquals(a[0].nodeName, "A");
     assertTrue(!a.attr("ng:bind-attr"));
   }));
 
-  it('ExistingAttrbindingIsAppended', inject(function($rootScope) {
-    var a = angular.compile("<a href='http://s/{{abc}}' ng:bind-attr='{\"b\":\"{{def}}\"}'></a>")($rootScope);
+  it('ExistingAttrbindingIsAppended', inject(function($rootScope, $compile) {
+    var a = $compile("<a href='http://s/{{abc}}' ng:bind-attr='{\"b\":\"{{def}}\"}'></a>")($rootScope);
     assertEquals('{"b":"{{def}}","href":"http://s/{{abc}}"}', a.attr('ng:bind-attr'));
   }));
 
-  it('AttributesAreEvaluated', inject(function($rootScope) {
-    var a = angular.compile('<a ng:bind-attr=\'{"a":"a", "b":"a+b={{a+b}}"}\'></a>')($rootScope);
+  it('AttributesAreEvaluated', inject(function($rootScope, $compile) {
+    var a = $compile('<a ng:bind-attr=\'{"a":"a", "b":"a+b={{a+b}}"}\'></a>')($rootScope);
     $rootScope.$eval('a=1;b=2');
     $rootScope.$apply();
     assertEquals(a.attr('a'), 'a');
     assertEquals(a.attr('b'), 'a+b=3');
   }));
 
-  it('InputTypeButtonActionExecutesInScope', inject(function($rootScope) {
+  it('InputTypeButtonActionExecutesInScope', inject(function($rootScope, $compile) {
     var savedCalled = false;
-    var element = angular.compile(
+    var element = $compile(
       '<input type="button" ng:click="person.save()" value="Apply">')($rootScope);
     $rootScope.person = {};
     $rootScope.person.save = function() {
@@ -112,9 +112,9 @@ describe('Binder', function() {
     assertTrue(savedCalled);
   }));
 
-  it('InputTypeButtonActionExecutesInScope2', inject(function($rootScope) {
+  it('InputTypeButtonActionExecutesInScope2', inject(function($rootScope, $compile) {
     var log = "";
-    var element = angular.compile('<input type="image" ng:click="action()">')($rootScope);
+    var element = $compile('<input type="image" ng:click="action()">')($rootScope);
     $rootScope.action = function() {
       log += 'click;';
     };
@@ -123,9 +123,9 @@ describe('Binder', function() {
     expect(log).toEqual('click;');
   }));
 
-  it('ButtonElementActionExecutesInScope', inject(function($rootScope) {
+  it('ButtonElementActionExecutesInScope', inject(function($rootScope, $compile) {
     var savedCalled = false;
-    var element = angular.compile('<button ng:click="person.save()">Apply</button>')($rootScope);
+    var element = $compile('<button ng:click="person.save()">Apply</button>')($rootScope);
     $rootScope.person = {};
     $rootScope.person.save = function() {
       savedCalled = true;
@@ -134,8 +134,8 @@ describe('Binder', function() {
     assertTrue(savedCalled);
   }));
 
-  it('RepeaterUpdateBindings', inject(function($rootScope) {
-    var form = angular.compile(
+  it('RepeaterUpdateBindings', inject(function($rootScope, $compile) {
+    var form = $compile(
       '<ul>' +
         '<LI ng:repeat="item in model.items" ng:bind="item.a"></LI>' +
       '</ul>')($rootScope);
@@ -171,8 +171,8 @@ describe('Binder', function() {
     $rootScope.$apply();
   }));
 
-  it('RepeaterContentDoesNotBind', inject(function($rootScope) {
-    var element = angular.compile(
+  it('RepeaterContentDoesNotBind', inject(function($rootScope, $compile) {
+    var element = $compile(
       '<ul>' +
         '<LI ng:repeat="item in model.items"><span ng:bind="item.a"></span></li>' +
       '</ul>')($rootScope);
@@ -189,8 +189,8 @@ describe('Binder', function() {
     assertTrue(html.indexOf('action="foo();"') > 0 );
   });
 
-  it('RepeaterAdd', inject(function($rootScope) {
-    var element = angular.compile('<div><input type="text" ng:model="item.x" ng:repeat="item in items"></div>')($rootScope);
+  it('RepeaterAdd', inject(function($rootScope, $compile) {
+    var element = $compile('<div><input type="text" ng:model="item.x" ng:repeat="item in items"></div>')($rootScope);
     $rootScope.items = [{x:'a'}, {x:'b'}];
     $rootScope.$apply();
     var first = childNode(element, 1);
@@ -204,8 +204,8 @@ describe('Binder', function() {
     expect($rootScope.items[0].x).toEqual('ABC');
   }));
 
-  it('ItShouldRemoveExtraChildrenWhenIteratingOverHash', inject(function($rootScope) {
-    var element = angular.compile('<div><div ng:repeat="i in items">{{i}}</div></div>')($rootScope);
+  it('ItShouldRemoveExtraChildrenWhenIteratingOverHash', inject(function($rootScope, $compile) {
+    var element = $compile('<div><div ng:repeat="i in items">{{i}}</div></div>')($rootScope);
     var items = {};
     $rootScope.items = items;
 
@@ -225,8 +225,8 @@ describe('Binder', function() {
     function(service){
       service('$exceptionHandler', $exceptionHandlerMockFactory);
     },
-    function($rootScope, $exceptionHandler) {
-      angular.compile('<div>{{error.throw()}}</div>', null, true)($rootScope);
+    function($rootScope, $exceptionHandler, $compile) {
+      $compile('<div>{{error.throw()}}</div>', null, true)($rootScope);
       var errorLogs = $exceptionHandler.errors;
 
       $rootScope.error = {
@@ -247,8 +247,8 @@ describe('Binder', function() {
 
   it('IfAttrBindingThrowsErrorDecorateTheAttribute', inject(function(service){
     service('$exceptionHandler', $exceptionHandlerMockFactory);
-  }, function($rootScope, $exceptionHandler) {
-    angular.compile('<div attr="before {{error.throw()}} after"></div>', null, true)($rootScope);
+  }, function($rootScope, $exceptionHandler, $compile) {
+    $compile('<div attr="before {{error.throw()}} after"></div>', null, true)($rootScope);
     var errorLogs = $exceptionHandler.errors;
     var count = 0;
 
@@ -265,8 +265,8 @@ describe('Binder', function() {
     expect(errorLogs.length).toMatch(0);
   }));
 
-  it('NestedRepeater', inject(function($rootScope) {
-    var element = angular.compile(
+  it('NestedRepeater', inject(function($rootScope, $compile) {
+    var element = $compile(
       '<div>' +
         '<div ng:repeat="m in model" name="{{m.name}}">' +
            '<ul name="{{i}}" ng:repeat="i in m.item"></ul>' +
@@ -290,8 +290,8 @@ describe('Binder', function() {
         '</div></div>', sortedHtml(element));
   }));
 
-  it('HideBindingExpression', inject(function($rootScope) {
-    var element = angular.compile('<div ng:hide="hidden == 3"/>')($rootScope);
+  it('HideBindingExpression', inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:hide="hidden == 3"/>')($rootScope);
 
     $rootScope.hidden = 3;
     $rootScope.$apply();
@@ -304,8 +304,8 @@ describe('Binder', function() {
     assertVisible(element);
   }));
 
-  it('HideBinding', inject(function($rootScope) {
-    var element = angular.compile('<div ng:hide="hidden"/>')($rootScope);
+  it('HideBinding', inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:hide="hidden"/>')($rootScope);
 
     $rootScope.hidden = 'true';
     $rootScope.$apply();
@@ -323,8 +323,8 @@ describe('Binder', function() {
     assertVisible(element);
   }));
 
-  it('ShowBinding', inject(function($rootScope) {
-    var element = angular.compile('<div ng:show="show"/>')($rootScope);
+  it('ShowBinding', inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:show="show"/>')($rootScope);
 
     $rootScope.show = 'true';
     $rootScope.$apply();
@@ -343,8 +343,8 @@ describe('Binder', function() {
   }));
 
 
-  it('BindClass', inject(function($rootScope) {
-    var element = angular.compile('<div ng:class="clazz"/>')($rootScope);
+  it('BindClass', inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:class="clazz"/>')($rootScope);
 
     $rootScope.clazz = 'testClass';
     $rootScope.$apply();
@@ -357,8 +357,8 @@ describe('Binder', function() {
     assertEquals('<div class="a b" ng:class="clazz"></div>', sortedHtml(element));
   }));
 
-  it('BindClassEvenOdd', inject(function($rootScope) {
-    var element = angular.compile(
+  it('BindClassEvenOdd', inject(function($rootScope, $compile) {
+    var element = $compile(
       '<div>' +
         '<div ng:repeat="i in [0,1]" ng:class-even="\'e\'" ng:class-odd="\'o\'"></div>' +
       '</div>')($rootScope);
@@ -374,8 +374,8 @@ describe('Binder', function() {
         sortedHtml(element));
   }));
 
-  it('BindStyle', inject(function($rootScope) {
-    var element = angular.compile('<div ng:style="style"/>')($rootScope);
+  it('BindStyle', inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:style="style"/>')($rootScope);
 
     $rootScope.$eval('style={height: "10px"}');
     $rootScope.$apply();
@@ -390,8 +390,8 @@ describe('Binder', function() {
     function(service){
       service('$exceptionHandler', $exceptionHandlerMockFactory);
     },
-    function($rootScope, $exceptionHandler) {
-      var input = angular.compile('<a ng:click="action()">Add Phone</a>')($rootScope);
+    function($rootScope, $exceptionHandler, $compile) {
+      var input = $compile('<a ng:click="action()">Add Phone</a>')($rootScope);
       $rootScope.action = function() {
         throw new Error('MyError');
       };
@@ -400,8 +400,8 @@ describe('Binder', function() {
     })
   );
 
-  it('ShoulIgnoreVbNonBindable', inject(function($rootScope) {
-    var element = angular.compile(
+  it('ShoulIgnoreVbNonBindable', inject(function($rootScope, $compile) {
+    var element = $compile(
       "<div>{{a}}" +
         "<div ng:non-bindable>{{a}}</div>" +
         "<div ng:non-bindable=''>{{b}}</div>" +
@@ -412,8 +412,8 @@ describe('Binder', function() {
     assertEquals('123{{a}}{{b}}{{c}}', element.text());
   }));
 
-  it('ShouldTemplateBindPreElements', inject(function ($rootScope) {
-    var element = angular.compile('<pre>Hello {{name}}!</pre>')($rootScope);
+  it('ShouldTemplateBindPreElements', inject(function ($rootScope, $compile) {
+    var element = $compile('<pre>Hello {{name}}!</pre>')($rootScope);
     $rootScope.name = "World";
     $rootScope.$apply();
 
@@ -422,8 +422,8 @@ describe('Binder', function() {
       sortedHtml(element));
   }));
 
-  it('FillInOptionValueWhenMissing', inject(function($rootScope) {
-    var element = angular.compile(
+  it('FillInOptionValueWhenMissing', inject(function($rootScope, $compile) {
+    var element = $compile(
         '<select ng:model="foo">' +
           '<option selected="true">{{a}}</option>' +
           '<option value="">{{b}}</option>' +
@@ -446,8 +446,8 @@ describe('Binder', function() {
     expect(optionC.text()).toEqual('C');
   }));
 
-  it('DeleteAttributeIfEvaluatesFalse', inject(function($rootScope) {
-    var element = angular.compile(
+  it('DeleteAttributeIfEvaluatesFalse', inject(function($rootScope, $compile) {
+    var element = $compile(
       '<div>' +
         '<input ng:model="a0" ng:bind-attr="{disabled:\'{{true}}\'}">' +
         '<input ng:model="a1" ng:bind-attr="{disabled:\'{{false}}\'}">' +
@@ -474,8 +474,8 @@ describe('Binder', function() {
     function(service){
       service('$exceptionHandler', $exceptionHandlerMockFactory);
     },
-    function($rootScope, $exceptionHandler, $log) {
-      var element = angular.compile(
+    function($rootScope, $exceptionHandler, $log, $compile) {
+      var element = $compile(
         '<div>' +
           '<input type="button" ng:click="greeting=\'ABC\'"/>' +
           '<input type="button" ng:click=":garbage:"/>' +
@@ -494,8 +494,8 @@ describe('Binder', function() {
     })
   );
 
-  it('ItShouldSelectTheCorrectRadioBox', inject(function($rootScope) {
-    var element = angular.compile(
+  it('ItShouldSelectTheCorrectRadioBox', inject(function($rootScope, $compile) {
+    var element = $compile(
       '<div>' +
         '<input type="radio" ng:model="sex" value="female">' +
         '<input type="radio" ng:model="sex" value="male">' +
@@ -516,8 +516,8 @@ describe('Binder', function() {
     assertEquals("male", male.val());
   }));
 
-  it('ItShouldRepeatOnHashes', inject(function($rootScope) {
-    var element = angular.compile(
+  it('ItShouldRepeatOnHashes', inject(function($rootScope, $compile) {
+    var element = $compile(
       '<ul>' +
         '<li ng:repeat="(k,v) in {a:0,b:1}" ng:bind=\"k + v\"></li>' +
       '</ul>')($rootScope);
@@ -530,8 +530,8 @@ describe('Binder', function() {
         sortedHtml(element));
   }));
 
-  it('ItShouldFireChangeListenersBeforeUpdate', inject(function($rootScope) {
-    var element = angular.compile('<div ng:bind="name"></div>')($rootScope);
+  it('ItShouldFireChangeListenersBeforeUpdate', inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:bind="name"></div>')($rootScope);
     $rootScope.name = "";
     $rootScope.$watch("watched", "name=123");
     $rootScope.watched = "change";
@@ -542,8 +542,8 @@ describe('Binder', function() {
         sortedHtml(element));
   }));
 
-  it('ItShouldHandleMultilineBindings', inject(function($rootScope) {
-    var element = angular.compile('<div>{{\n 1 \n + \n 2 \n}}</div>')($rootScope);
+  it('ItShouldHandleMultilineBindings', inject(function($rootScope, $compile) {
+    var element = $compile('<div>{{\n 1 \n + \n 2 \n}}</div>')($rootScope);
     $rootScope.$apply();
     assertEquals("3", element.text());
   }));
diff --git a/test/ResourceSpec.js b/test/ResourceSpec.js
index 75d81a89..928b4f6c 100644
--- a/test/ResourceSpec.js
+++ b/test/ResourceSpec.js
@@ -221,8 +221,8 @@ describe("resource", function() {
     nakedExpect(visa).toEqual({id:123});
   }));
 
-  it('should excersize full stack', inject(function($rootScope, $browser, $resource) {
-    angular.compile('<div></div>')($rootScope);
+  it('should excersize full stack', inject(function($rootScope, $browser, $resource, $compile) {
+    $compile('<div></div>')($rootScope);
     var Person = $resource('/Person/:id');
     $browser.xhr.expectGET('/Person/123').respond('\n{\n"name":\n"misko"\n}\n');
     var person = Person.get({id:123});
@@ -230,8 +230,8 @@ describe("resource", function() {
     expect(person.name).toEqual('misko');
   }));
 
-  it('should return the same object when verifying the cache', inject(function($rootScope) {
-    angular.compile('<div></div>')($rootScope);
+  it('should return the same object when verifying the cache', inject(function($rootScope, $compile) {
+    $compile('<div></div>')($rootScope);
     var $browser = $rootScope.$service('$browser');
     var $resource = $rootScope.$service('$resource');
     var Person = $resource('/Person/:id', null, {query: {method:'GET', isArray: true, verifyCache: true}});
diff --git a/test/ScenarioSpec.js b/test/ScenarioSpec.js
index d33e880d..986e2121 100644
--- a/test/ScenarioSpec.js
+++ b/test/ScenarioSpec.js
@@ -2,22 +2,22 @@
 
 describe("ScenarioSpec: Compilation", function() {
   describe('compilation', function() {
-    it("should compile dom node and return scope", inject(function($rootScope) {
+    it("should compile dom node and return scope", inject(function($rootScope, $compile) {
       var node = jqLite('<div ng:init="a=1">{{b=a+1}}</div>')[0];
-      angular.compile(node)($rootScope);
+      $compile(node)($rootScope);
       $rootScope.$digest();
       expect($rootScope.a).toEqual(1);
       expect($rootScope.b).toEqual(2);
     }));
 
-    it("should compile jQuery node and return scope", inject(function($rootScope) {
-      var element = compile(jqLite('<div>{{a=123}}</div>'))($rootScope);
+    it("should compile jQuery node and return scope", inject(function($rootScope, $compile) {
+      var element = $compile(jqLite('<div>{{a=123}}</div>'))($rootScope);
       $rootScope.$digest();
       expect(jqLite(element).text()).toEqual('123');
     }));
 
-    it("should compile text node and return scope", inject(function($rootScope) {
-      var element = angular.compile('<div>{{a=123}}</div>')($rootScope);
+    it("should compile text node and return scope", inject(function($rootScope, $compile) {
+      var element = $compile('<div>{{a=123}}</div>')($rootScope);
       $rootScope.$digest();
       expect(jqLite(element).text()).toEqual('123');
     }));
diff --git a/test/directivesSpec.js b/test/directivesSpec.js
index eb74d227..96d0993b 100644
--- a/test/directivesSpec.js
+++ b/test/directivesSpec.js
@@ -2,14 +2,14 @@
 
 describe("directive", function() {
 
-  it("should ng:init", inject(function($rootScope) {
-    var element = angular.compile('<div ng:init="a=123"></div>')($rootScope);
+  it("should ng:init", inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:init="a=123"></div>')($rootScope);
     expect($rootScope.a).toEqual(123);
   }));
 
   describe('ng:bind', function() {
-    it('should set text', inject(function($rootScope) {
-      var element = angular.compile('<div ng:bind="a"></div>')($rootScope);
+    it('should set text', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:bind="a"></div>')($rootScope);
       expect(element.text()).toEqual('');
       $rootScope.a = 'misko';
       $rootScope.$digest();
@@ -17,8 +17,8 @@ describe("directive", function() {
       expect(element.text()).toEqual('misko');
     }));
 
-    it('should set text to blank if undefined', inject(function($rootScope) {
-      var element = angular.compile('<div ng:bind="a"></div>')($rootScope);
+    it('should set text to blank if undefined', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:bind="a"></div>')($rootScope);
       $rootScope.a = 'misko';
       $rootScope.$digest();
       expect(element.text()).toEqual('misko');
@@ -27,76 +27,76 @@ describe("directive", function() {
       expect(element.text()).toEqual('');
     }));
 
-    it('should set html', inject(function($rootScope) {
-      var element = angular.compile('<div ng:bind="html|html"></div>')($rootScope);
+    it('should set html', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:bind="html|html"></div>')($rootScope);
       $rootScope.html = '<div unknown>hello</div>';
       $rootScope.$digest();
       expect(lowercase(element.html())).toEqual('<div>hello</div>');
     }));
 
-    it('should set unsafe html', inject(function($rootScope) {
-      var element = angular.compile('<div ng:bind="html|html:\'unsafe\'"></div>')($rootScope);
+    it('should set unsafe html', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:bind="html|html:\'unsafe\'"></div>')($rootScope);
       $rootScope.html = '<div onclick="">hello</div>';
       $rootScope.$digest();
       expect(lowercase(element.html())).toEqual('<div onclick="">hello</div>');
     }));
 
-    it('should set element element', inject(function($rootScope) {
+    it('should set element element', inject(function($rootScope, $compile) {
       angularFilter.myElement = function() {
         return jqLite('<a>hello</a>');
       };
-      var element = angular.compile('<div ng:bind="0|myElement"></div>')($rootScope);
+      var element = $compile('<div ng:bind="0|myElement"></div>')($rootScope);
       $rootScope.$digest();
       expect(lowercase(element.html())).toEqual('<a>hello</a>');
     }));
 
-    it('should have $element set to current bind element', inject(function($rootScope) {
+    it('should have $element set to current bind element', inject(function($rootScope, $compile) {
       angularFilter.myFilter = function() {
         this.$element.addClass("filter");
         return 'HELLO';
       };
-      var element = angular.compile('<div>before<div ng:bind="0|myFilter"></div>after</div>')($rootScope);
+      var element = $compile('<div>before<div ng:bind="0|myFilter"></div>after</div>')($rootScope);
       $rootScope.$digest();
       expect(sortedHtml(element)).toEqual('<div>before<div class="filter" ng:bind="0|myFilter">HELLO</div>after</div>');
     }));
 
 
-    it('should suppress rendering of falsy values', inject(function($rootScope) {
-      var element = angular.compile('<div>{{ null }}{{ undefined }}{{ "" }}-{{ 0 }}{{ false }}</div>')($rootScope);
+    it('should suppress rendering of falsy values', inject(function($rootScope, $compile) {
+      var element = $compile('<div>{{ null }}{{ undefined }}{{ "" }}-{{ 0 }}{{ false }}</div>')($rootScope);
       $rootScope.$digest();
       expect(element.text()).toEqual('-0false');
     }));
 
-    it('should render object as JSON ignore $$', inject(function($rootScope) {
-      var element = angular.compile('<div>{{ {key:"value", $$key:"hide"}  }}</div>')($rootScope);
+    it('should render object as JSON ignore $$', inject(function($rootScope, $compile) {
+      var element = $compile('<div>{{ {key:"value", $$key:"hide"}  }}</div>')($rootScope);
       $rootScope.$digest();
       expect(fromJson(element.text())).toEqual({key:'value'});
     }));
   });
 
   describe('ng:bind-template', function() {
-    it('should ng:bind-template', inject(function($rootScope) {
-      var element = angular.compile('<div ng:bind-template="Hello {{name}}!"></div>')($rootScope);
+    it('should ng:bind-template', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:bind-template="Hello {{name}}!"></div>')($rootScope);
       $rootScope.name = 'Misko';
       $rootScope.$digest();
       expect(element.hasClass('ng-binding')).toEqual(true);
       expect(element.text()).toEqual('Hello Misko!');
     }));
 
-    it('should have $element set to current bind element', inject(function($rootScope) {
+    it('should have $element set to current bind element', inject(function($rootScope, $compile) {
       var innerText;
       angularFilter.myFilter = function(text) {
         innerText = innerText || this.$element.text();
         return text;
       };
-      var element = angular.compile('<div>before<span ng:bind-template="{{\'HELLO\'|myFilter}}">INNER</span>after</div>')($rootScope);
+      var element = $compile('<div>before<span ng:bind-template="{{\'HELLO\'|myFilter}}">INNER</span>after</div>')($rootScope);
       $rootScope.$digest();
       expect(element.text()).toEqual("beforeHELLOafter");
       expect(innerText).toEqual('INNER');
     }));
 
-    it('should render object as JSON ignore $$', inject(function($rootScope) {
-      var element = angular.compile('<pre>{{ {key:"value", $$key:"hide"}  }}</pre>')($rootScope);
+    it('should render object as JSON ignore $$', inject(function($rootScope, $compile) {
+      var element = $compile('<pre>{{ {key:"value", $$key:"hide"}  }}</pre>')($rootScope);
       $rootScope.$digest();
       expect(fromJson(element.text())).toEqual({key:'value'});
     }));
@@ -104,22 +104,22 @@ describe("directive", function() {
   });
 
   describe('ng:bind-attr', function() {
-    it('should bind attributes', inject(function($rootScope) {
-      var element = angular.compile('<div ng:bind-attr="{src:\'http://localhost/mysrc\', alt:\'myalt\'}"/>')($rootScope);
+    it('should bind attributes', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:bind-attr="{src:\'http://localhost/mysrc\', alt:\'myalt\'}"/>')($rootScope);
       $rootScope.$digest();
       expect(element.attr('src')).toEqual('http://localhost/mysrc');
       expect(element.attr('alt')).toEqual('myalt');
     }));
 
-    it('should not pretty print JSON in attributes', inject(function($rootScope) {
-      var element = angular.compile('<img alt="{{ {a:1} }}"/>')($rootScope);
+    it('should not pretty print JSON in attributes', inject(function($rootScope, $compile) {
+      var element = $compile('<img alt="{{ {a:1} }}"/>')($rootScope);
       $rootScope.$digest();
       expect(element.attr('alt')).toEqual('{"a":1}');
     }));
   });
 
-  it('should remove special attributes on false', inject(function($rootScope) {
-    var element = angular.compile('<input ng:bind-attr="{disabled:\'{{disabled}}\', readonly:\'{{readonly}}\', checked:\'{{checked}}\'}"/>')($rootScope);
+  it('should remove special attributes on false', inject(function($rootScope, $compile) {
+    var element = $compile('<input ng:bind-attr="{disabled:\'{{disabled}}\', readonly:\'{{readonly}}\', checked:\'{{checked}}\'}"/>')($rootScope);
     var input = element[0];
     expect(input.disabled).toEqual(false);
     expect(input.readOnly).toEqual(false);
@@ -136,8 +136,8 @@ describe("directive", function() {
   }));
 
   describe('ng:click', function() {
-    it('should get called on a click', inject(function($rootScope) {
-      var element = angular.compile('<div ng:click="clicked = true"></div>')($rootScope);
+    it('should get called on a click', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:click="clicked = true"></div>')($rootScope);
       $rootScope.$digest();
       expect($rootScope.clicked).toBeFalsy();
 
@@ -145,8 +145,8 @@ describe("directive", function() {
       expect($rootScope.clicked).toEqual(true);
     }));
 
-    it('should stop event propagation', inject(function($rootScope) {
-      var element = angular.compile('<div ng:click="outer = true"><div ng:click="inner = true"></div></div>')($rootScope);
+    it('should stop event propagation', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:click="outer = true"><div ng:click="inner = true"></div></div>')($rootScope);
       $rootScope.$digest();
       expect($rootScope.outer).not.toBeDefined();
       expect($rootScope.inner).not.toBeDefined();
@@ -161,8 +161,8 @@ describe("directive", function() {
 
 
   describe('ng:submit', function() {
-    it('should get called on form submit', inject(function($rootScope) {
-      var element = angular.compile('<form action="" ng:submit="submitted = true">' +
+    it('should get called on form submit', inject(function($rootScope, $compile) {
+      var element = $compile('<form action="" ng:submit="submitted = true">' +
         '<input type="submit"/>' +
         '</form>')($rootScope);
       $rootScope.$digest();
@@ -174,8 +174,8 @@ describe("directive", function() {
   });
 
   describe('ng:class', function() {
-    it('should add new and remove old classes dynamically', inject(function($rootScope) {
-      var element = angular.compile('<div class="existing" ng:class="dynClass"></div>')($rootScope);
+    it('should add new and remove old classes dynamically', inject(function($rootScope, $compile) {
+      var element = $compile('<div class="existing" ng:class="dynClass"></div>')($rootScope);
       $rootScope.dynClass = 'A';
       $rootScope.$digest();
       expect(element.hasClass('existing')).toBe(true);
@@ -195,8 +195,8 @@ describe("directive", function() {
     }));
 
 
-    it('should support adding multiple classes via an array', inject(function($rootScope) {
-      var element = angular.compile('<div class="existing" ng:class="[\'A\', \'B\']"></div>')($rootScope);
+    it('should support adding multiple classes via an array', inject(function($rootScope, $compile) {
+      var element = $compile('<div class="existing" ng:class="[\'A\', \'B\']"></div>')($rootScope);
       $rootScope.$digest();
       expect(element.hasClass('existing')).toBeTruthy();
       expect(element.hasClass('A')).toBeTruthy();
@@ -204,8 +204,8 @@ describe("directive", function() {
     }));
 
 
-    it('should support adding multiple classes via a space delimited string', inject(function($rootScope) {
-      var element = angular.compile('<div class="existing" ng:class="\'A B\'"></div>')($rootScope);
+    it('should support adding multiple classes via a space delimited string', inject(function($rootScope, $compile) {
+      var element = $compile('<div class="existing" ng:class="\'A B\'"></div>')($rootScope);
       $rootScope.$digest();
       expect(element.hasClass('existing')).toBeTruthy();
       expect(element.hasClass('A')).toBeTruthy();
@@ -213,8 +213,8 @@ describe("directive", function() {
     }));
 
 
-    it('should preserve class added post compilation with pre-existing classes', inject(function($rootScope) {
-      var element = angular.compile('<div class="existing" ng:class="dynClass"></div>')($rootScope);
+    it('should preserve class added post compilation with pre-existing classes', inject(function($rootScope, $compile) {
+      var element = $compile('<div class="existing" ng:class="dynClass"></div>')($rootScope);
       $rootScope.dynClass = 'A';
       $rootScope.$digest();
       expect(element.hasClass('existing')).toBe(true);
@@ -230,8 +230,8 @@ describe("directive", function() {
     }));
 
 
-    it('should preserve class added post compilation without pre-existing classes"', inject(function($rootScope) {
-      var element = angular.compile('<div ng:class="dynClass"></div>')($rootScope);
+    it('should preserve class added post compilation without pre-existing classes"', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:class="dynClass"></div>')($rootScope);
       $rootScope.dynClass = 'A';
       $rootScope.$digest();
       expect(element.hasClass('A')).toBe(true);
@@ -246,8 +246,8 @@ describe("directive", function() {
     }));
 
 
-    it('should preserve other classes with similar name"', inject(function($rootScope) {
-      var element = angular.compile('<div class="ui-panel ui-selected" ng:class="dynCls"></div>')($rootScope);
+    it('should preserve other classes with similar name"', inject(function($rootScope, $compile) {
+      var element = $compile('<div class="ui-panel ui-selected" ng:class="dynCls"></div>')($rootScope);
       $rootScope.dynCls = 'panel';
       $rootScope.$digest();
       $rootScope.dynCls = 'foo';
@@ -256,16 +256,16 @@ describe("directive", function() {
     }));
 
 
-    it('should not add duplicate classes', inject(function($rootScope) {
-      var element = angular.compile('<div class="panel bar" ng:class="dynCls"></div>')($rootScope);
+    it('should not add duplicate classes', inject(function($rootScope, $compile) {
+      var element = $compile('<div class="panel bar" ng:class="dynCls"></div>')($rootScope);
       $rootScope.dynCls = 'panel';
       $rootScope.$digest();
       expect(element[0].className).toBe('panel bar ng-directive');
     }));
 
 
-    it('should remove classes even if it was specified via class attribute', inject(function($rootScope) {
-      var element = angular.compile('<div class="panel bar" ng:class="dynCls"></div>')($rootScope);
+    it('should remove classes even if it was specified via class attribute', inject(function($rootScope, $compile) {
+      var element = $compile('<div class="panel bar" ng:class="dynCls"></div>')($rootScope);
       $rootScope.dynCls = 'panel';
       $rootScope.$digest();
       $rootScope.dynCls = 'window';
@@ -274,8 +274,8 @@ describe("directive", function() {
     }));
 
 
-    it('should remove classes even if they were added by another code', inject(function($rootScope) {
-      var element = angular.compile('<div ng:class="dynCls"></div>')($rootScope);
+    it('should remove classes even if they were added by another code', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:class="dynCls"></div>')($rootScope);
       $rootScope.dynCls = 'foo';
       $rootScope.$digest();
       element.addClass('foo');
@@ -285,8 +285,8 @@ describe("directive", function() {
     }));
 
 
-    it('should convert undefined and null values to an empty string', inject(function($rootScope) {
-      var element = angular.compile('<div ng:class="dynCls"></div>')($rootScope);
+    it('should convert undefined and null values to an empty string', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:class="dynCls"></div>')($rootScope);
       $rootScope.dynCls = [undefined, null];
       $rootScope.$digest();
       expect(element[0].className).toBe('ng-directive');
@@ -294,8 +294,8 @@ describe("directive", function() {
   });
 
 
-  it('should ng:class odd/even', inject(function($rootScope) {
-    var element = angular.compile('<ul><li ng:repeat="i in [0,1]" class="existing" ng:class-odd="\'odd\'" ng:class-even="\'even\'"></li><ul>')($rootScope);
+  it('should ng:class odd/even', inject(function($rootScope, $compile) {
+    var element = $compile('<ul><li ng:repeat="i in [0,1]" class="existing" ng:class-odd="\'odd\'" ng:class-even="\'even\'"></li><ul>')($rootScope);
     $rootScope.$digest();
     var e1 = jqLite(element[0].childNodes[1]);
     var e2 = jqLite(element[0].childNodes[2]);
@@ -306,8 +306,8 @@ describe("directive", function() {
   }));
 
 
-  it('should allow both ng:class and ng:class-odd/even on the same element', inject(function($rootScope) {
-    var element = angular.compile('<ul>' +
+  it('should allow both ng:class and ng:class-odd/even on the same element', inject(function($rootScope, $compile) {
+    var element = $compile('<ul>' +
       '<li ng:repeat="i in [0,1]" ng:class="\'plainClass\'" ' +
       'ng:class-odd="\'odd\'" ng:class-even="\'even\'"></li>' +
       '<ul>')($rootScope);
@@ -324,8 +324,8 @@ describe("directive", function() {
   }));
 
 
-  it('should allow both ng:class and ng:class-odd/even with multiple classes', inject(function($rootScope) {
-    var element = angular.compile('<ul>' +
+  it('should allow both ng:class and ng:class-odd/even with multiple classes', inject(function($rootScope, $compile) {
+    var element = $compile('<ul>' +
       '<li ng:repeat="i in [0,1]" ng:class="[\'A\', \'B\']" ' +
       'ng:class-odd="[\'C\', \'D\']" ng:class-even="[\'E\', \'F\']"></li>' +
       '<ul>')($rootScope);
@@ -351,15 +351,15 @@ describe("directive", function() {
 
   describe('ng:style', function() {
 
-    it('should set', inject(function($rootScope) {
-      var element = angular.compile('<div ng:style="{height: \'40px\'}"></div>')($rootScope);
+    it('should set', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:style="{height: \'40px\'}"></div>')($rootScope);
       $rootScope.$digest();
       expect(element.css('height')).toEqual('40px');
     }));
 
 
-    it('should silently ignore undefined style', inject(function($rootScope) {
-      var element = angular.compile('<div ng:style="myStyle"></div>')($rootScope);
+    it('should silently ignore undefined style', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:style="myStyle"></div>')($rootScope);
       $rootScope.$digest();
       expect(element.hasClass('ng-exception')).toBeFalsy();
     }));
@@ -368,7 +368,7 @@ describe("directive", function() {
     describe('preserving styles set before and after compilation', function() {
       var scope, preCompStyle, preCompVal, postCompStyle, postCompVal, element;
 
-      beforeEach(inject(function($rootScope) {
+      beforeEach(inject(function($rootScope, $compile) {
         preCompStyle = 'width';
         preCompVal = '300px';
         postCompStyle = 'height';
@@ -376,7 +376,7 @@ describe("directive", function() {
         element = jqLite('<div ng:style="styleObj"></div>');
         element.css(preCompStyle, preCompVal);
         jqLite(document.body).append(element);
-        angular.compile(element)($rootScope);
+        $compile(element)($rootScope);
         scope = $rootScope;
         scope.styleObj = {'margin-top': '44px'};
         scope.$apply();
@@ -431,9 +431,9 @@ describe("directive", function() {
 
 
   describe('ng:show', function() {
-    it('should show and hide an element', inject(function($rootScope) {
+    it('should show and hide an element', inject(function($rootScope, $compile) {
       var element = jqLite('<div ng:show="exp"></div>');
-      var element = angular.compile(element)($rootScope);
+      var element = $compile(element)($rootScope);
       $rootScope.$digest();
       expect(isCssVisible(element)).toEqual(false);
       $rootScope.exp = true;
@@ -442,9 +442,9 @@ describe("directive", function() {
     }));
 
 
-    it('should make hidden element visible', inject(function($rootScope) {
+    it('should make hidden element visible', inject(function($rootScope, $compile) {
       var element = jqLite('<div style="display: none" ng:show="exp"></div>');
-      var element = angular.compile(element)($rootScope);
+      var element = $compile(element)($rootScope);
       expect(isCssVisible(element)).toBe(false);
       $rootScope.exp = true;
       $rootScope.$digest();
@@ -453,9 +453,9 @@ describe("directive", function() {
   });
 
   describe('ng:hide', function() {
-    it('should hide an element', inject(function($rootScope) {
+    it('should hide an element', inject(function($rootScope, $compile) {
       var element = jqLite('<div ng:hide="exp"></div>');
-      var element = angular.compile(element)($rootScope);
+      var element = $compile(element)($rootScope);
       expect(isCssVisible(element)).toBe(true);
       $rootScope.exp = true;
       $rootScope.$digest();
@@ -485,13 +485,13 @@ describe("directive", function() {
       window.temp = undefined;
     });
 
-    it('should bind', inject(function($rootScope) {
-      var element = angular.compile('<div ng:controller="temp.Greeter"></div>')($rootScope);
+    it('should bind', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:controller="temp.Greeter"></div>')($rootScope);
       expect($rootScope.greeter.greeting).toEqual('hello');
       expect($rootScope.greeter.greet('misko')).toEqual('hello misko!');
     }));
 
-    it('should support nested controllers', inject(function($rootScope) {
+    it('should support nested controllers', inject(function($rootScope, $compile) {
       temp.ChildGreeter = function() {
         this.greeting = 'hey';
         this.$root.childGreeter = this;
@@ -501,7 +501,7 @@ describe("directive", function() {
           return this.greeting + ' dude' + this.suffix;
         }
       };
-      var element = angular.compile('<div ng:controller="temp.Greeter"><div ng:controller="temp.ChildGreeter">{{greet("misko")}}</div></div>')($rootScope);
+      var element = $compile('<div ng:controller="temp.Greeter"><div ng:controller="temp.ChildGreeter">{{greet("misko")}}</div></div>')($rootScope);
       expect($rootScope.greeting).not.toBeDefined();
       expect($rootScope.greeter.greeting).toEqual('hello');
       expect($rootScope.greeter.greet('misko')).toEqual('hello misko!');
@@ -512,33 +512,33 @@ describe("directive", function() {
       expect(element.text()).toEqual('hey dude!');
     }));
 
-    it('should infer injection arguments', inject(function($rootScope) {
+    it('should infer injection arguments', inject(function($rootScope, $compile) {
       temp.MyController = function($xhr){
         this.$root.someService = $xhr;
       };
-      var element = angular.compile('<div ng:controller="temp.MyController"></div>')($rootScope);
+      var element = $compile('<div ng:controller="temp.MyController"></div>')($rootScope);
       expect($rootScope.someService).toBe($rootScope.$service('$xhr'));
     }));
   });
 
   describe('ng:cloak', function() {
 
-    it('should get removed when an element is compiled', inject(function($rootScope) {
+    it('should get removed when an element is compiled', inject(function($rootScope, $compile) {
       var element = jqLite('<div ng:cloak></div>');
       expect(element.attr('ng:cloak')).toBe('');
-      angular.compile(element);
+      $compile(element);
       expect(element.attr('ng:cloak')).toBeUndefined();
     }));
 
 
-    it('should remove ng-cloak class from a compiled element', inject(function($rootScope) {
+    it('should remove ng-cloak class from a compiled element', inject(function($rootScope, $compile) {
       var element = jqLite('<div ng:cloak class="foo ng-cloak bar"></div>');
 
       expect(element.hasClass('foo')).toBe(true);
       expect(element.hasClass('ng-cloak')).toBe(true);
       expect(element.hasClass('bar')).toBe(true);
 
-      angular.compile(element);
+      $compile(element);
 
       expect(element.hasClass('foo')).toBe(true);
       expect(element.hasClass('ng-cloak')).toBe(false);
diff --git a/test/markupSpec.js b/test/markupSpec.js
index d97dbcb5..c23cc62d 100644
--- a/test/markupSpec.js
+++ b/test/markupSpec.js
@@ -2,16 +2,16 @@
 
 describe("markups", function() {
 
-  it('should translate {{}} in text', inject(function($rootScope) {
-    var element = angular.compile('<div>hello {{name}}!</div>')($rootScope)
+  it('should translate {{}} in text', inject(function($rootScope, $compile) {
+    var element = $compile('<div>hello {{name}}!</div>')($rootScope)
     expect(sortedHtml(element)).toEqual('<div>hello <span ng:bind="name"></span>!</div>');
     $rootScope.name = 'Misko';
     $rootScope.$digest();
     expect(sortedHtml(element)).toEqual('<div>hello <span ng:bind="name">Misko</span>!</div>');
   }));
 
-  it('should translate {{}} in terminal nodes', inject(function($rootScope) {
-    var element = angular.compile('<select ng:model="x"><option value="">Greet {{name}}!</option></select>')($rootScope)
+  it('should translate {{}} in terminal nodes', inject(function($rootScope, $compile) {
+    var element = $compile('<select ng:model="x"><option value="">Greet {{name}}!</option></select>')($rootScope)
     $rootScope.$digest();
     expect(sortedHtml(element).replace(' selected="true"', '')).
       toEqual('<select ng:model="x">' +
@@ -25,8 +25,8 @@ describe("markups", function() {
               '</select>');
   }));
 
-  it('should translate {{}} in attributes', inject(function($rootScope) {
-    var element = angular.compile('<div src="http://server/{{path}}.png"/>')($rootScope)
+  it('should translate {{}} in attributes', inject(function($rootScope, $compile) {
+    var element = $compile('<div src="http://server/{{path}}.png"/>')($rootScope)
     expect(element.attr('ng:bind-attr')).toEqual('{"src":"http://server/{{path}}.png"}');
     $rootScope.path = 'a/b';
     $rootScope.$digest();
@@ -55,37 +55,37 @@ describe("markups", function() {
     });
 
 
-    it('should populate value attribute on OPTION', inject(function($rootScope) {
-      var element = angular.compile('<select ng:model="x"><option>abc</option></select>')($rootScope)
+    it('should populate value attribute on OPTION', inject(function($rootScope, $compile) {
+      var element = $compile('<select ng:model="x"><option>abc</option></select>')($rootScope)
       expect(element).toHaveValue('abc');
     }));
 
-    it('should ignore value if already exists', inject(function($rootScope) {
-      var element = angular.compile('<select ng:model="x"><option value="abc">xyz</option></select>')($rootScope)
+    it('should ignore value if already exists', inject(function($rootScope, $compile) {
+      var element = $compile('<select ng:model="x"><option value="abc">xyz</option></select>')($rootScope)
       expect(element).toHaveValue('abc');
     }));
 
-    it('should set value even if newlines present', inject(function($rootScope) {
-      var element = angular.compile('<select ng:model="x"><option attr="\ntext\n" \n>\nabc\n</option></select>')($rootScope)
+    it('should set value even if newlines present', inject(function($rootScope, $compile) {
+      var element = $compile('<select ng:model="x"><option attr="\ntext\n" \n>\nabc\n</option></select>')($rootScope)
       expect(element).toHaveValue('\nabc\n');
     }));
 
-    it('should set value even if self closing HTML', inject(function($rootScope) {
+    it('should set value even if self closing HTML', inject(function($rootScope, $compile) {
       // IE removes the \n from option, which makes this test pointless
       if (msie) return;
-      var element = angular.compile('<select ng:model="x"><option>\n</option></select>')($rootScope)
+      var element = $compile('<select ng:model="x"><option>\n</option></select>')($rootScope)
       expect(element).toHaveValue('\n');
     }));
 
   });
 
-  it('should bind href', inject(function($rootScope) {
-    var element = angular.compile('<a ng:href="{{url}}"></a>')($rootScope)
+  it('should bind href', inject(function($rootScope, $compile) {
+    var element = $compile('<a ng:href="{{url}}"></a>')($rootScope)
     expect(sortedHtml(element)).toEqual('<a ng:bind-attr="{"href":"{{url}}"}"></a>');
   }));
 
-  it('should bind disabled', inject(function($rootScope) {
-    var element = angular.compile('<button ng:disabled="{{isDisabled}}">Button</button>')($rootScope)
+  it('should bind disabled', inject(function($rootScope, $compile) {
+    var element = $compile('<button ng:disabled="{{isDisabled}}">Button</button>')($rootScope)
     $rootScope.isDisabled = false;
     $rootScope.$digest();
     expect(element.attr('disabled')).toBeFalsy();
@@ -94,8 +94,8 @@ describe("markups", function() {
     expect(element.attr('disabled')).toBeTruthy();
   }));
 
-  it('should bind checked', inject(function($rootScope) {
-    var element = angular.compile('<input type="checkbox" ng:checked="{{isChecked}}" />')($rootScope)
+  it('should bind checked', inject(function($rootScope, $compile) {
+    var element = $compile('<input type="checkbox" ng:checked="{{isChecked}}" />')($rootScope)
     $rootScope.isChecked = false;
     $rootScope.$digest();
     expect(element.attr('checked')).toBeFalsy();
@@ -104,8 +104,8 @@ describe("markups", function() {
     expect(element.attr('checked')).toBeTruthy();
   }));
 
-  it('should bind selected', inject(function($rootScope) {
-    var element = angular.compile('<select><option value=""></option><option ng:selected="{{isSelected}}">Greetings!</option></select>')($rootScope)
+  it('should bind selected', inject(function($rootScope, $compile) {
+    var element = $compile('<select><option value=""></option><option ng:selected="{{isSelected}}">Greetings!</option></select>')($rootScope)
     jqLite(document.body).append(element)
     $rootScope.isSelected=false;
     $rootScope.$digest();
@@ -115,8 +115,8 @@ describe("markups", function() {
     expect(element.children()[1].selected).toBeTruthy();
   }));
 
-  it('should bind readonly', inject(function($rootScope) {
-    var element = angular.compile('<input type="text" ng:readonly="{{isReadonly}}" />')($rootScope)
+  it('should bind readonly', inject(function($rootScope, $compile) {
+    var element = $compile('<input type="text" ng:readonly="{{isReadonly}}" />')($rootScope)
     $rootScope.isReadonly=false;
     $rootScope.$digest();
     expect(element.attr('readOnly')).toBeFalsy();
@@ -125,8 +125,8 @@ describe("markups", function() {
     expect(element.attr('readOnly')).toBeTruthy();
   }));
 
-  it('should bind multiple', inject(function($rootScope) {
-    var element = angular.compile('<select ng:multiple="{{isMultiple}}"></select>')($rootScope)
+  it('should bind multiple', inject(function($rootScope, $compile) {
+    var element = $compile('<select ng:multiple="{{isMultiple}}"></select>')($rootScope)
     $rootScope.isMultiple=false;
     $rootScope.$digest();
     expect(element.attr('multiple')).toBeFalsy();
@@ -135,57 +135,57 @@ describe("markups", function() {
     expect(element.attr('multiple')).toBeTruthy();
   }));
 
-  it('should bind src', inject(function($rootScope) {
-    var element = angular.compile('<div ng:src="{{url}}" />')($rootScope)
+  it('should bind src', inject(function($rootScope, $compile) {
+    var element = $compile('<div ng:src="{{url}}" />')($rootScope)
     $rootScope.url = 'http://localhost/';
     $rootScope.$digest();
     expect(element.attr('src')).toEqual('http://localhost/');
   }));
 
-  it('should bind href and merge with other attrs', inject(function($rootScope) {
-    var element = angular.compile('<a ng:href="{{url}}" rel="{{rel}}"></a>')($rootScope)
+  it('should bind href and merge with other attrs', inject(function($rootScope, $compile) {
+    var element = $compile('<a ng:href="{{url}}" rel="{{rel}}"></a>')($rootScope)
     expect(sortedHtml(element)).toEqual('<a ng:bind-attr="{"href":"{{url}}","rel":"{{rel}}"}"></a>');
   }));
 
-  it('should bind Text with no Bindings', inject(function() {
+  it('should bind Text with no Bindings', inject(function($compile) {
     var $rootScope;
     function newScope (){
       return $rootScope = angular.injector()('$rootScope');
     }
     forEach(['checked', 'disabled', 'multiple', 'readonly', 'selected'], function(name) {
-      var element = angular.compile('<div ng:' + name + '="some"></div>')(newScope())
+      var element = $compile('<div ng:' + name + '="some"></div>')(newScope())
       expect(element.attr('ng:bind-attr')).toBe('{"' + name +'":"some"}');
       $rootScope.$digest();
       expect(element.attr(name)).toBe(name);
       dealoc(element);
     });
 
-    var element = angular.compile('<div ng:src="some"></div>')(newScope())
+    var element = $compile('<div ng:src="some"></div>')(newScope())
     $rootScope.$digest();
     expect(sortedHtml(element)).toEqual('<div ng:bind-attr="{"src":"some"}" src="some"></div>');
     dealoc(element);
 
-    var element = angular.compile('<div ng:href="some"></div>')(newScope())
+    var element = $compile('<div ng:href="some"></div>')(newScope())
     $rootScope.$digest();
     expect(sortedHtml(element)).toEqual('<div href="some" ng:bind-attr="{"href":"some"}"></div>');
     dealoc(element);
   }));
 
-  it('should Parse Text With No Bindings', inject(function($rootScope) {
+  it('should Parse Text With No Bindings', inject(function($rootScope, $compile) {
     var parts = parseBindings("a");
     assertEquals(parts.length, 1);
     assertEquals(parts[0], "a");
     assertTrue(!binding(parts[0]));
   }));
 
-  it('should Parse Empty Text', inject(function($rootScope) {
+  it('should Parse Empty Text', inject(function($rootScope, $compile) {
     var parts = parseBindings("");
     assertEquals(parts.length, 1);
     assertEquals(parts[0], "");
     assertTrue(!binding(parts[0]));
   }));
 
-  it('should Parse Inner Binding', inject(function($rootScope) {
+  it('should Parse Inner Binding', inject(function($rootScope, $compile) {
     var parts = parseBindings("a{{b}}C");
     assertEquals(parts.length, 3);
     assertEquals(parts[0], "a");
@@ -196,7 +196,7 @@ describe("markups", function() {
     assertTrue(!binding(parts[2]));
   }));
 
-  it('should Parse Ending Binding', inject(function($rootScope) {
+  it('should Parse Ending Binding', inject(function($rootScope, $compile) {
     var parts = parseBindings("a{{b}}");
     assertEquals(parts.length, 2);
     assertEquals(parts[0], "a");
@@ -205,7 +205,7 @@ describe("markups", function() {
     assertEquals(binding(parts[1]), "b");
   }));
 
-  it('should Parse Begging Binding', inject(function($rootScope) {
+  it('should Parse Begging Binding', inject(function($rootScope, $compile) {
     var parts = parseBindings("{{b}}c");
     assertEquals(parts.length, 2);
     assertEquals(parts[0], "{{b}}");
@@ -214,14 +214,14 @@ describe("markups", function() {
     assertTrue(!binding(parts[1]));
   }));
 
-  it('should Parse Loan Binding', inject(function($rootScope) {
+  it('should Parse Loan Binding', inject(function($rootScope, $compile) {
     var parts = parseBindings("{{b}}");
     assertEquals(parts.length, 1);
     assertEquals(parts[0], "{{b}}");
     assertEquals(binding(parts[0]), "b");
   }));
 
-  it('should Parse Two Bindings', inject(function($rootScope) {
+  it('should Parse Two Bindings', inject(function($rootScope, $compile) {
     var parts = parseBindings("{{b}}{{c}}");
     assertEquals(parts.length, 2);
     assertEquals(parts[0], "{{b}}");
@@ -230,7 +230,7 @@ describe("markups", function() {
     assertEquals(binding(parts[1]), "c");
   }));
 
-  it('should Parse Two Bindings With Text In Middle', inject(function($rootScope) {
+  it('should Parse Two Bindings With Text In Middle', inject(function($rootScope, $compile) {
     var parts = parseBindings("{{b}}x{{c}}");
     assertEquals(parts.length, 3);
     assertEquals(parts[0], "{{b}}");
@@ -241,7 +241,7 @@ describe("markups", function() {
     assertEquals(binding(parts[2]), "c");
   }));
 
-  it('should Parse Multiline', inject(function($rootScope) {
+  it('should Parse Multiline', inject(function($rootScope, $compile) {
     var parts = parseBindings('"X\nY{{A\nB}}C\nD"');
     assertTrue(!!binding('{{A\nB}}'));
     assertEquals(parts.length, 3);
@@ -250,7 +250,7 @@ describe("markups", function() {
     assertEquals(parts[2], 'C\nD"');
   }));
 
-  it('should Has Binding', inject(function($rootScope) {
+  it('should Has Binding', inject(function($rootScope, $compile) {
     assertTrue(hasBindings(parseBindings("{{a}}")));
     assertTrue(!hasBindings(parseBindings("a")));
     assertTrue(hasBindings(parseBindings("{{b}}x{{c}}")));
diff --git a/test/service/compilerSpec.js b/test/service/compilerSpec.js
index 2dec1396..4e0dbed6 100644
--- a/test/service/compilerSpec.js
+++ b/test/service/compilerSpec.js
@@ -1,10 +1,12 @@
 'use strict';
 
 describe('compiler', function() {
-  var compiler, markup, attrMarkup, directives, widgets, compile, log, scope;
+  var compiler, textMmarkup, attrMarkup, directives, widgets, compile, log, $rootScope;
 
-  beforeEach(inject(function($rootScope) {
-    log = "";
+  beforeEach(inject(function(service){
+    textMmarkup = [];
+    attrMarkup = [];
+    widgets = extensionMap({}, 'widget');
     directives = {
       hello: function(expression, element){
         log += "hello ";
@@ -23,29 +25,25 @@ describe('compiler', function() {
       }
 
     };
-    markup = [];
-    attrMarkup = [];
-    widgets = extensionMap({}, 'widget');
-    compiler = new Compiler(markup, attrMarkup, directives, widgets);
-    compile = function(html){
-      var e = jqLite("<div>" + html + "</div>");
-      compiler.compile(e)($rootScope);
-      return scope = $rootScope;
-    };
+    log = "";
+    service('$textMarkup', valueFn(textMmarkup));
+    service('$attrMarkup', valueFn(attrMarkup));
+    service('$directive', valueFn(directives));
+    service('$widget', valueFn(widgets));
   }));
 
 
-  it('should not allow compilation of multiple roots', function() {
+  it('should not allow compilation of multiple roots', inject(function($rootScope, $compile) {
     expect(function() {
-      compiler.compile('<div>A</div><span></span>');
+      $compile('<div>A</div><span></span>');
     }).toThrow("Cannot compile multiple element roots: " + ie("<div>A</div><span></span>"));
     function ie(text) {
       return msie < 9 ? uppercase(text) : text;
     }
-  });
+  }));
 
 
-  it('should recognize a directive', inject(function($rootScope) {
+  it('should recognize a directive', inject(function($rootScope, $compile) {
     var e = jqLite('<div directive="expr" ignore="me"></div>');
     directives.directive = function(expression, element){
       log += "found";
@@ -55,42 +53,42 @@ describe('compiler', function() {
         log += ":init";
       };
     };
-    var template = compiler.compile(e);
+    var linkFn = $compile(e);
     expect(log).toEqual("found");
-    scope = template($rootScope);
+    linkFn($rootScope);
     expect(e.hasClass('ng-directive')).toEqual(true);
     expect(log).toEqual("found:init");
   }));
 
 
-  it('should recurse to children', function() {
-    scope = compile('<div><span hello="misko"/></div>');
+  it('should recurse to children', inject(function($rootScope, $compile) {
+    $compile('<div><span hello="misko"/></div>')($rootScope);
     expect(log).toEqual("hello misko");
-  });
+  }));
 
 
-  it('should observe scope', function() {
-    scope = compile('<span observe="name"></span>');
+  it('should observe scope', inject(function($rootScope, $compile) {
+    $compile('<span observe="name"></span>')($rootScope);
     expect(log).toEqual("");
-    scope.$digest();
-    scope.name = 'misko';
-    scope.$digest();
-    scope.$digest();
-    scope.name = 'adam';
-    scope.$digest();
-    scope.$digest();
+    $rootScope.$digest();
+    $rootScope.name = 'misko';
+    $rootScope.$digest();
+    $rootScope.$digest();
+    $rootScope.name = 'adam';
+    $rootScope.$digest();
+    $rootScope.$digest();
     expect(log).toEqual(":misko:adam");
-  });
+  }));
 
 
-  it('should prevent descend', function() {
+  it('should prevent descend', inject(function($rootScope, $compile) {
     directives.stop = function() { this.descend(false); };
-    scope = compile('<span hello="misko" stop="true"><span hello="adam"/></span>');
+    $compile('<span hello="misko" stop="true"><span hello="adam"/></span>')($rootScope);
     expect(log).toEqual("hello misko");
-  });
+  }));
 
 
-  it('should allow creation of templates', inject(function($rootScope) {
+  it('should allow creation of templates', inject(function($rootScope, $compile) {
     directives.duplicate = function(expr, element){
       element.replaceWith(document.createComment("marker"));
       element.removeAttr("duplicate");
@@ -103,32 +101,32 @@ describe('compiler', function() {
         });
       };
     };
-    scope = compile('before<span duplicate="expr">x</span>after');
-    expect(sortedHtml(scope.$element)).
+    $compile('<div>before<span duplicate="expr">x</span>after</div>')($rootScope);
+    expect(sortedHtml($rootScope.$element)).
       toEqual('<div>' +
                 'before<#comment></#comment>' +
                 'after' +
               '</div>');
-    scope.value = 1;
-    scope.$digest();
-    expect(sortedHtml(scope.$element)).
+    $rootScope.value = 1;
+    $rootScope.$digest();
+    expect(sortedHtml($rootScope.$element)).
       toEqual('<div>' +
           'before<#comment></#comment>' +
           '<span>x</span>' +
           'after' +
         '</div>');
-    scope.value = 2;
-    scope.$digest();
-    expect(sortedHtml(scope.$element)).
+    $rootScope.value = 2;
+    $rootScope.$digest();
+    expect(sortedHtml($rootScope.$element)).
       toEqual('<div>' +
           'before<#comment></#comment>' +
           '<span>x</span>' +
           '<span>x</span>' +
           'after' +
         '</div>');
-    scope.value = 3;
-    scope.$digest();
-    expect(sortedHtml(scope.$element)).
+    $rootScope.value = 3;
+    $rootScope.$digest();
+    expect(sortedHtml($rootScope.$element)).
       toEqual('<div>' +
           'before<#comment></#comment>' +
           '<span>x</span>' +
@@ -139,21 +137,22 @@ describe('compiler', function() {
   }));
 
 
-  it('should process markup before directives', function() {
-    markup.push(function(text, textNode, parentNode) {
+  it('should process markup before directives', inject(function($rootScope, $compile) {
+    textMmarkup.push(function(text, textNode, parentNode) {
       if (text == 'middle') {
         expect(textNode.text()).toEqual(text);
         parentNode.attr('hello', text);
         textNode[0].nodeValue = 'replaced';
       }
     });
-    scope = compile('before<span>middle</span>after');
-    expect(sortedHtml(scope.$element[0], true)).toEqual('<div>before<span class="ng-directive" hello="middle">replaced</span>after</div>');
+    $compile('<div>before<span>middle</span>after</div>')($rootScope);
+    expect(sortedHtml($rootScope.$element[0], true)).
+      toEqual('<div>before<span class="ng-directive" hello="middle">replaced</span>after</div>');
     expect(log).toEqual("hello middle");
-  });
+  }));
 
 
-  it('should replace widgets', function() {
+  it('should replace widgets', inject(function($rootScope, $compile) {
     widgets['NG:BUTTON'] = function(element) {
       expect(element.hasClass('ng-widget')).toEqual(true);
       element.replaceWith('<div>button</div>');
@@ -161,13 +160,13 @@ describe('compiler', function() {
         log += 'init';
       };
     };
-    scope = compile('<ng:button>push me</ng:button>');
-    expect(lowercase(scope.$element[0].innerHTML)).toEqual('<div>button</div>');
+    $compile('<div><ng:button>push me</ng:button></div>')($rootScope);
+    expect(lowercase($rootScope.$element[0].innerHTML)).toEqual('<div>button</div>');
     expect(log).toEqual('init');
-  });
+  }));
 
 
-  it('should use the replaced element after calling widget', function() {
+  it('should use the replaced element after calling widget', inject(function($rootScope, $compile) {
     widgets['H1'] = function(element) {
       // HTML elements which are augmented by acting as widgets, should not be marked as so
       expect(element.hasClass('ng-widget')).toEqual(false);
@@ -177,17 +176,17 @@ describe('compiler', function() {
       this.directives(true);
       return noop;
     };
-    markup.push(function(text, textNode, parent){
+    textMmarkup.push(function(text, textNode, parent){
       if (text == '{{1+2}}')
         parent.text('3');
     });
-    scope = compile('<div><h1>ignore me</h1></div>');
-    expect(scope.$element.text()).toEqual('3');
-  });
+    $compile('<div><h1>ignore me</h1></div>')($rootScope);
+    expect($rootScope.$element.text()).toEqual('3');
+  }));
 
 
-  it('should allow multiple markups per text element', function() {
-    markup.push(function(text, textNode, parent){
+  it('should allow multiple markups per text element', inject(function($rootScope, $compile) {
+    textMmarkup.push(function(text, textNode, parent){
       var index = text.indexOf('---');
       if (index > -1) {
         textNode.after(text.substring(index + 3));
@@ -196,7 +195,7 @@ describe('compiler', function() {
         textNode.remove();
       }
     });
-    markup.push(function(text, textNode, parent){
+    textMmarkup.push(function(text, textNode, parent){
       var index = text.indexOf('===');
       if (index > -1) {
         textNode.after(text.substring(index + 3));
@@ -205,14 +204,13 @@ describe('compiler', function() {
         textNode.remove();
       }
     });
-    scope = compile('A---B---C===D');
-    expect(sortedHtml(scope.$element)).toEqual('<div>A<hr></hr>B<hr></hr>C<p></p>D</div>');
-  });
+    $compile('<div>A---B---C===D</div>')($rootScope);
+    expect(sortedHtml($rootScope.$element)).toEqual('<div>A<hr></hr>B<hr></hr>C<p></p>D</div>');
+  }));
 
 
-  it('should add class for namespace elements', function() {
-    scope = compile('<ng:space>abc</ng:space>');
-    var space = jqLite(scope.$element[0].firstChild);
-    expect(space.hasClass('ng-space')).toEqual(true);
-  });
+  it('should add class for namespace elements', inject(function($rootScope, $compile) {
+    var element = $compile('<ng:space>abc</ng:space>')($rootScope);
+    expect(element.hasClass('ng-space')).toEqual(true);
+  }));
 });
diff --git a/test/testabilityPatch.js b/test/testabilityPatch.js
index 3d964149..154db7d0 100644
--- a/test/testabilityPatch.js
+++ b/test/testabilityPatch.js
@@ -125,7 +125,6 @@ function inject(){
 function resetAngularPublic() {
   extend(angular, {
     'element': jqLite,
-    'compile': compile,
     'copy': copy,
     'extend': extend,
     'equals': equals,
diff --git a/test/widget/formSpec.js b/test/widget/formSpec.js
index a30f21eb..7a92dbf4 100644
--- a/test/widget/formSpec.js
+++ b/test/widget/formSpec.js
@@ -8,17 +8,17 @@ describe('form', function() {
   });
 
 
-  it('should attach form to DOM', inject(function($rootScope) {
+  it('should attach form to DOM', inject(function($rootScope, $compile) {
     doc = angular.element('<form>');
-    angular.compile(doc)($rootScope);
+    $compile(doc)($rootScope);
     expect(doc.data('$form')).toBeTruthy();
   }));
 
 
-  it('should prevent form submission', inject(function($rootScope) {
+  it('should prevent form submission', inject(function($rootScope, $compile) {
     var startingUrl = '' + window.location;
     doc = angular.element('<form name="myForm"><input type=submit val=submit>');
-    angular.compile(doc)($rootScope);
+    $compile(doc)($rootScope);
     browserTrigger(doc.find('input'));
     waitsFor(
         function() { return true; },
@@ -29,18 +29,18 @@ describe('form', function() {
   }));
 
 
-  it('should publish form to scope', inject(function($rootScope) {
+  it('should publish form to scope', inject(function($rootScope, $compile) {
     doc = angular.element('<form name="myForm"></form>');
-    angular.compile(doc)($rootScope);
+    $compile(doc)($rootScope);
     expect($rootScope.myForm).toBeTruthy();
     expect(doc.data('$form')).toBeTruthy();
     expect(doc.data('$form')).toEqual($rootScope.myForm);
   }));
 
 
-  it('should have ng-valide/ng-invalid style', inject(function($rootScope) {
+  it('should have ng-valide/ng-invalid style', inject(function($rootScope, $compile) {
     doc = angular.element('<form name="myForm"><input type=text ng:model=text required>');
-    angular.compile(doc)($rootScope);
+    $compile(doc)($rootScope);
     $rootScope.text = 'misko';
     $rootScope.$digest();
 
@@ -54,14 +54,14 @@ describe('form', function() {
   }));
 
 
-  it('should chain nested forms', inject(function($rootScope) {
+  it('should chain nested forms', inject(function($rootScope, $compile) {
     doc = angular.element(
         '<ng:form name=parent>' +
           '<ng:form name=child>' +
             '<input type=text ng:model=text name=text>' +
           '</ng:form>' +
         '</ng:form>');
-    angular.compile(doc)($rootScope);
+    $compile(doc)($rootScope);
     var parent = $rootScope.parent;
     var child = $rootScope.child;
     var input = child.text;
@@ -76,14 +76,14 @@ describe('form', function() {
   }));
 
 
-  it('should chain nested forms in repeater', inject(function($rootScope) {
+  it('should chain nested forms in repeater', inject(function($rootScope, $compile) {
     doc = angular.element(
        '<ng:form name=parent>' +
         '<ng:form ng:repeat="f in forms" name=child>' +
           '<input type=text ng:model=text name=text>' +
          '</ng:form>' +
        '</ng:form>');
-    angular.compile(doc)($rootScope);
+    $compile(doc)($rootScope);
     $rootScope.forms = [1];
     $rootScope.$digest();
 
diff --git a/test/widget/inputSpec.js b/test/widget/inputSpec.js
index a889212f..6ab53ab0 100644
--- a/test/widget/inputSpec.js
+++ b/test/widget/inputSpec.js
@@ -2,10 +2,12 @@
 
 describe('widget: input', function() {
   var compile = null, element = null, scope = null, defer = null;
+  var $compile = null;
   var doc = null;
 
-  beforeEach(inject(function($rootScope) {
+  beforeEach(inject(function($rootScope, $compile) {
     scope = $rootScope;
+    set$compile($compile);
     element = null;
     compile = function(html, parent) {
       if (parent) {
@@ -14,13 +16,15 @@ describe('widget: input', function() {
       } else {
         element = jqLite(html);
       }
-      angular.compile(element)(scope);
+      $compile(element)(scope);
       scope.$apply();
       defer = scope.$service('$browser').defer;
       return scope;
     };
   }));
 
+  function set$compile(c) { $compile = c; }
+
   afterEach(function() {
     dealoc(element);
     dealoc(doc);
@@ -40,7 +44,7 @@ describe('widget: input', function() {
       formElement = doc = angular.element('<form name="form"><input ' + prefix +
           'type="text" ng:model="name" name="name" ng:change="change()"></form>');
       inputElement = formElement.find('input');
-      angular.compile(doc)(scope);
+      $compile(doc)(scope);
       form = formElement.inheritedData('$form');
     };
 
@@ -90,16 +94,16 @@ describe('widget: input', function() {
     });
 
 
-    it('should change non-html5 types to text', inject(function($rootScope) {
+    it('should change non-html5 types to text', inject(function($rootScope, $compile) {
       doc = angular.element('<form name="form"><input type="abc" ng:model="name"></form>');
-      angular.compile(doc)($rootScope);
+      $compile(doc)($rootScope);
       expect(doc.find('input').attr('type')).toEqual('text');
     }));
 
 
-    it('should not change html5 types to text', inject(function($rootScope) {
+    it('should not change html5 types to text', inject(function($rootScope, $compile) {
       doc = angular.element('<form name="form"><input type="number" ng:model="name"></form>');
-      angular.compile(doc)($rootScope);
+      $compile(doc)($rootScope);
       expect(doc.find('input')[0].getAttribute('type')).toEqual('number');
     }));
   });
@@ -454,7 +458,7 @@ describe('widget: input', function() {
 
 
   describe('scope declaration', function() {
-    it('should read the declaration from scope', inject(function($rootScope) {
+    it('should read the declaration from scope', inject(function($rootScope, $compile) {
       var input, $formFactory;
       element = angular.element('<input type="@MyType" ng:model="abc">');
       $rootScope.MyType = function($f, i) {
@@ -463,18 +467,18 @@ describe('widget: input', function() {
       };
       $rootScope.MyType.$inject = ['$formFactory'];
 
-      angular.compile(element)($rootScope);
+      $compile(element)($rootScope);
 
       expect($formFactory).toBe($rootScope.$service('$formFactory'));
       expect(input[0]).toBe(element[0]);
     }));
 
-    it('should throw an error of Controller not declared in scope', inject(function($rootScope) {
+    it('should throw an error of Controller not declared in scope', inject(function($rootScope, $compile) {
       var input, $formFactory;
       element = angular.element('<input type="@DontExist" ng:model="abc">');
       var error;
       try {
-        angular.compile(element)($rootScope);
+        $compile(element)($rootScope);
         error = 'no error thrown';
       } catch (e) {
         error = e;
@@ -577,9 +581,9 @@ describe('widget: input', function() {
         {'ng:maxlength': 3});
 
 
-    it('should throw an error when scope pattern can\'t be found', inject(function($rootScope) {
+    it('should throw an error when scope pattern can\'t be found', inject(function($rootScope, $compile) {
       var el = jqLite('<input ng:model="foo" ng:pattern="fooRegexp">');
-      angular.compile(el)($rootScope);
+      $compile(el)($rootScope);
 
       el.val('xx');
       browserTrigger(el, 'keydown');
diff --git a/test/widget/selectSpec.js b/test/widget/selectSpec.js
index 31e5223d..5d92e674 100644
--- a/test/widget/selectSpec.js
+++ b/test/widget/selectSpec.js
@@ -3,7 +3,7 @@
 describe('select', function() {
   var compile = null, element = null, scope = null;
 
-  beforeEach(inject(function($rootScope) {
+  beforeEach(inject(function($compile, $rootScope) {
     scope = $rootScope;
     element = null;
     compile = function(html, parent) {
@@ -13,7 +13,7 @@ describe('select', function() {
       } else {
         element = jqLite(html);
       }
-      angular.compile(element)($rootScope);
+      $compile(element)($rootScope);
       scope.$apply();
       return scope;
     };
diff --git a/test/widgetsSpec.js b/test/widgetsSpec.js
index 1a4c5e6c..d2204540 100644
--- a/test/widgetsSpec.js
+++ b/test/widgetsSpec.js
@@ -1,9 +1,10 @@
 'use strict';
 
 describe("widget", function() {
-  describe('ng:switch', inject(function($rootScope) {
-    it('should switch on value change', inject(function($rootScope) {
-      var element = angular.compile('<ng:switch on="select">' +
+  describe('ng:switch', inject(function($rootScope, $compile) {
+    it('should switch on value change', inject(function($rootScope, $compile) {
+      var element = $compile(
+        '<ng:switch on="select">' +
           '<div ng:switch-when="1">first:{{name}}</div>' +
           '<div ng:switch-when="2">second:{{name}}</div>' +
           '<div ng:switch-when="true">true:{{name}}</div>' +
@@ -27,8 +28,8 @@ describe("widget", function() {
     }));
     
 
-    it('should switch on switch-when-default', inject(function($rootScope) {
-      var element = angular.compile(
+    it('should switch on switch-when-default', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ng:switch on="select">' +
           '<div ng:switch-when="1">one</div>' +
           '<div ng:switch-default>other</div>' +
@@ -41,8 +42,8 @@ describe("widget", function() {
     }));
 
     
-    it('should call change on switch', inject(function($rootScope) {
-      var element = angular.compile(
+    it('should call change on switch', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ng:switch on="url" change="name=\'works\'">' +
           '<div ng:switch-when="a">{{name}}</div>' +
         '</ng:switch>')($rootScope);
@@ -54,10 +55,10 @@ describe("widget", function() {
   }));
 
 
-  describe('ng:include', inject(function($rootScope) {
-    it('should include on external file', inject(function($rootScope) {
+  describe('ng:include', inject(function($rootScope, $compile) {
+    it('should include on external file', inject(function($rootScope, $compile) {
       var element = jqLite('<ng:include src="url" scope="childScope"></ng:include>');
-      var element = angular.compile(element)($rootScope);
+      var element = $compile(element)($rootScope);
       $rootScope.childScope = $rootScope.$new();
       $rootScope.childScope.name = 'misko';
       $rootScope.url = 'myUrl';
@@ -67,9 +68,9 @@ describe("widget", function() {
     }));
 
     
-    it('should remove previously included text if a falsy value is bound to src', inject(function($rootScope) {
+    it('should remove previously included text if a falsy value is bound to src', inject(function($rootScope, $compile) {
       var element = jqLite('<ng:include src="url" scope="childScope"></ng:include>');
-      var element = angular.compile(element)($rootScope);
+      var element = $compile(element)($rootScope);
       $rootScope.childScope = $rootScope.$new();
       $rootScope.childScope.name = 'igor';
       $rootScope.url = 'myUrl';
@@ -85,9 +86,9 @@ describe("widget", function() {
     }));
 
     
-    it('should allow this for scope', inject(function($rootScope) {
+    it('should allow this for scope', inject(function($rootScope, $compile) {
       var element = jqLite('<ng:include src="url" scope="this"></ng:include>');
-      var element = angular.compile(element)($rootScope);
+      var element = $compile(element)($rootScope);
       $rootScope.url = 'myUrl';
       $rootScope.$service('$xhr.cache').data.myUrl = {value:'{{"abc"}}'};
       $rootScope.$digest();
@@ -101,9 +102,9 @@ describe("widget", function() {
     }));
 
     
-    it('should evaluate onload expression when a partial is loaded', inject(function($rootScope) {
+    it('should evaluate onload expression when a partial is loaded', inject(function($rootScope, $compile) {
       var element = jqLite('<ng:include src="url" onload="loaded = true"></ng:include>');
-      var element = angular.compile(element)($rootScope);
+      var element = $compile(element)($rootScope);
 
       expect($rootScope.loaded).not.toBeDefined();
 
@@ -115,9 +116,9 @@ describe("widget", function() {
     }));
 
     
-    it('should destroy old scope', inject(function($rootScope) {
+    it('should destroy old scope', inject(function($rootScope, $compile) {
       var element = jqLite('<ng:include src="url"></ng:include>');
-      var element = angular.compile(element)($rootScope);
+      var element = $compile(element)($rootScope);
 
       expect($rootScope.$$childHead).toBeFalsy();
 
@@ -133,13 +134,13 @@ describe("widget", function() {
   }));
 
 
-  describe('a', inject(function($rootScope) {
-    it('should prevent default action to be executed when href is empty', inject(function($rootScope) {
+  describe('a', inject(function($rootScope, $compile) {
+    it('should prevent default action to be executed when href is empty', inject(function($rootScope, $compile) {
       var orgLocation = document.location.href,
           preventDefaultCalled = false,
           event;
 
-      var element = angular.compile('<a href="">empty link</a>')($rootScope);
+      var element = $compile('<a href="">empty link</a>')($rootScope);
 
       if (msie < 9) {
 
@@ -169,9 +170,9 @@ describe("widget", function() {
   }));
 
 
-  describe('@ng:repeat', inject(function($rootScope) {
-    it('should ng:repeat over array', inject(function($rootScope) {
-      var element = angular.compile(
+  describe('@ng:repeat', inject(function($rootScope, $compile) {
+    it('should ng:repeat over array', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ul>' +
           '<li ng:repeat="item in items" ng:init="suffix = \';\'" ng:bind="item + suffix"></li>' +
         '</ul>')($rootScope);
@@ -197,8 +198,8 @@ describe("widget", function() {
       expect(element.text()).toEqual('brad;');
     }));
 
-    it('should ng:repeat over object', inject(function($rootScope) {
-      var element = angular.compile(
+    it('should ng:repeat over object', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ul>' +
           '<li ng:repeat="(key, value) in items" ng:bind="key + \':\' + value + \';\' "></li>' +
         '</ul>')($rootScope);
@@ -207,12 +208,12 @@ describe("widget", function() {
       expect(element.text()).toEqual('misko:swe;shyam:set;');
     }));
 
-    it('should not ng:repeat over parent properties', inject(function($rootScope) {
+    it('should not ng:repeat over parent properties', inject(function($rootScope, $compile) {
       var Class = function() {};
       Class.prototype.abc = function() {};
       Class.prototype.value = 'abc';
 
-      var element = angular.compile(
+      var element = $compile(
         '<ul>' +
           '<li ng:repeat="(key, value) in items" ng:bind="key + \':\' + value + \';\' "></li>' +
         '</ul>')($rootScope);
@@ -222,16 +223,16 @@ describe("widget", function() {
       expect(element.text()).toEqual('name:value;');
     }));
 
-    it('should error on wrong parsing of ng:repeat', inject(function($rootScope) {
+    it('should error on wrong parsing of ng:repeat', inject(function($rootScope, $compile) {
       expect(function() {
-        var element = angular.compile('<ul><li ng:repeat="i dont parse"></li></ul>')($rootScope);
+        var element = $compile('<ul><li ng:repeat="i dont parse"></li></ul>')($rootScope);
       }).toThrow("Expected ng:repeat in form of '_item_ in _collection_' but got 'i dont parse'.");
 
       $logMock.error.logs.shift();
     }));
 
-    it('should expose iterator offset as $index when iterating over arrays', inject(function($rootScope) {
-      var element = angular.compile(
+    it('should expose iterator offset as $index when iterating over arrays', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ul>' +
           '<li ng:repeat="item in items" ng:bind="item + $index + \'|\'"></li>' +
         '</ul>')($rootScope);
@@ -240,8 +241,8 @@ describe("widget", function() {
       expect(element.text()).toEqual('misko0|shyam1|frodo2|');
     }));
 
-    it('should expose iterator offset as $index when iterating over objects', inject(function($rootScope) {
-      var element = angular.compile(
+    it('should expose iterator offset as $index when iterating over objects', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ul>' +
           '<li ng:repeat="(key, val) in items" ng:bind="key + \':\' + val + $index + \'|\'"></li>' +
         '</ul>')($rootScope);
@@ -250,9 +251,8 @@ describe("widget", function() {
       expect(element.text()).toEqual('frodo:f0|misko:m1|shyam:s2|');
     }));
 
-    it('should expose iterator position as $position when iterating over arrays',
-        inject(function($rootScope) {
-      var element = angular.compile(
+    it('should expose iterator position as $position when iterating over arrays', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ul>' +
           '<li ng:repeat="item in items" ng:bind="item + \':\' + $position + \'|\'"></li>' +
         '</ul>')($rootScope);
@@ -270,8 +270,8 @@ describe("widget", function() {
       expect(element.text()).toEqual('misko:first|shyam:last|');
     }));
 
-    it('should expose iterator position as $position when iterating over objects', inject(function($rootScope) {
-      var element = angular.compile(
+    it('should expose iterator position as $position when iterating over objects', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ul>' +
           '<li ng:repeat="(key, val) in items" ng:bind="key + \':\' + val + \':\' + $position + \'|\'">' +
           '</li>' +
@@ -286,8 +286,8 @@ describe("widget", function() {
       expect(element.text()).toEqual('misko:m:first|shyam:s:last|');
     }));
 
-    it('should ignore $ and $$ properties', inject(function($rootScope) {
-      var element = angular.compile('<ul><li ng:repeat="i in items">{{i}}|</li></ul>')($rootScope);
+    it('should ignore $ and $$ properties', inject(function($rootScope, $compile) {
+      var element = $compile('<ul><li ng:repeat="i in items">{{i}}|</li></ul>')($rootScope);
       $rootScope.items = ['a', 'b', 'c'];
       $rootScope.items.$$hashkey = 'xxx';
       $rootScope.items.$root = 'yyy';
@@ -296,8 +296,8 @@ describe("widget", function() {
       expect(element.text()).toEqual('a|b|c|');
     }));
 
-    it('should repeat over nested arrays', inject(function($rootScope) {
-      var element = angular.compile(
+    it('should repeat over nested arrays', inject(function($rootScope, $compile) {
+      var element = $compile(
         '<ul>' +
           '<li ng:repeat="subgroup in groups">' +
             '<div ng:repeat="group in subgroup">{{group}}|</div>X' +
@@ -309,8 +309,8 @@ describe("widget", function() {
       expect(element.text()).toEqual('a|b|Xc|d|X');
     }));
 
-    it('should ignore non-array element properties when iterating over an array', inject(function($rootScope) {
-      var element = angular.compile('<ul><li ng:repeat="item in array">{{item}}|</li></ul>')($rootScope);
+    it('should ignore non-array element properties when iterating over an array', inject(function($rootScope, $compile) {
+      var element = $compile('<ul><li ng:repeat="item in array">{{item}}|</li></ul>')($rootScope);
       $rootScope.array = ['a', 'b', 'c'];
       $rootScope.array.foo = '23';
       $rootScope.array.bar = function() {};
@@ -319,8 +319,8 @@ describe("widget", function() {
       expect(element.text()).toBe('a|b|c|');
     }));
 
-    it('should iterate over non-existent elements of a sparse array', inject(function($rootScope) {
-      var element = angular.compile('<ul><li ng:repeat="item in array">{{item}}|</li></ul>')($rootScope);
+    it('should iterate over non-existent elements of a sparse array', inject(function($rootScope, $compile) {
+      var element = $compile('<ul><li ng:repeat="item in array">{{item}}|</li></ul>')($rootScope);
       $rootScope.array = ['a', 'b'];
       $rootScope.array[4] = 'c';
       $rootScope.array[6] = 'd';
@@ -333,8 +333,8 @@ describe("widget", function() {
     describe('stability', function() {
       var a, b, c, d, lis, element;
 
-      beforeEach(inject(function($rootScope) {
-        element = angular.compile(
+      beforeEach(inject(function($rootScope, $compile) {
+        element = $compile(
           '<ul>' +
             '<li ng:repeat="item in items" ng:bind="key + \':\' + val + \':\' + $position + \'|\'"></li>' +
           '</ul>')($rootScope);
@@ -348,7 +348,7 @@ describe("widget", function() {
         lis = element.find('li');
       }));
 
-      it('should preserve the order of elements', inject(function($rootScope) {
+      it('should preserve the order of elements', inject(function($rootScope, $compile) {
         $rootScope.items = [a, c, d];
         $rootScope.$digest();
         var newElements = element.find('li');
@@ -357,7 +357,7 @@ describe("widget", function() {
         expect(newElements[2]).not.toEqual(lis[1]);
       }));
 
-      it('should support duplicates', inject(function($rootScope) {
+      it('should support duplicates', inject(function($rootScope, $compile) {
         $rootScope.items = [a, a, b, c];
         $rootScope.$digest();
         var newElements = element.find('li');
@@ -382,7 +382,7 @@ describe("widget", function() {
         expect(newElements[3]).toEqual(lis[3]);
       }));
 
-      it('should remove last item when one duplicate instance is removed', inject(function($rootScope) {
+      it('should remove last item when one duplicate instance is removed', inject(function($rootScope, $compile) {
         $rootScope.items = [a, a, a];
         $rootScope.$digest();
         lis = element.find('li');
@@ -395,7 +395,7 @@ describe("widget", function() {
         expect(newElements[1]).toEqual(lis[1]);
       }));
 
-      it('should reverse items when the collection is reversed', inject(function($rootScope) {
+      it('should reverse items when the collection is reversed', inject(function($rootScope, $compile) {
         $rootScope.items = [a, b, c];
         $rootScope.$digest();
         lis = element.find('li');
@@ -413,8 +413,8 @@ describe("widget", function() {
 
 
   describe('@ng:non-bindable', function() {
-    it('should prevent compilation of the owning element and its children', inject(function($rootScope) {
-      var element = angular.compile('<div ng:non-bindable><span ng:bind="name"></span></div>')($rootScope);
+    it('should prevent compilation of the owning element and its children', inject(function($rootScope, $compile) {
+      var element = $compile('<div ng:non-bindable><span ng:bind="name"></span></div>')($rootScope);
       $rootScope.name =  'misko';
       $rootScope.$digest();
       expect(element.text()).toEqual('');
@@ -424,19 +424,19 @@ describe("widget", function() {
 
   describe('ng:view', function() {
     var element;
-    beforeEach(inject(function($rootScope) {
-      element = angular.compile('<ng:view></ng:view>')($rootScope);
+    beforeEach(inject(function($rootScope, $compile) {
+      element = $compile('<ng:view></ng:view>')($rootScope);
     }));
 
 
-    it('should do nothing when no routes are defined', inject(function($rootScope, $location) {
+    it('should do nothing when no routes are defined', inject(function($rootScope, $compile, $location) {
       $location.path('/unknown');
       $rootScope.$digest();
       expect(element.text()).toEqual('');
     }));
 
 
-    it('should load content via xhr when route changes', inject(function($rootScope, $browser, $location, $route) {
+    it('should load content via xhr when route changes', inject(function($rootScope, $compile, $browser, $location, $route) {
       $route.when('/foo', {template: 'myUrl1'});
       $route.when('/bar', {template: 'myUrl2'});
 
@@ -456,7 +456,7 @@ describe("widget", function() {
     }));
 
     it('should remove all content when location changes to an unknown route',
-        inject(function($rootScope, $location, $browser, $route) {
+        inject(function($rootScope, $compile, $location, $browser, $route) {
       $route.when('/foo', {template: 'myUrl1'});
 
       $location.path('/foo');
@@ -471,7 +471,7 @@ describe("widget", function() {
     }));
 
     it('should chain scopes and propagate evals to the child scope',
-        inject(function($rootScope, $location, $browser, $route) {
+        inject(function($rootScope, $compile, $location, $browser, $route) {
       $route.when('/foo', {template: 'myUrl1'});
       $rootScope.parentVar = 'parent';
 
@@ -496,7 +496,7 @@ describe("widget", function() {
       var $route = injector('$route');
       $route.when('/foo', {controller: angular.noop, template: 'viewPartial.html'});
 
-      var element = angular.compile(
+      var element = injector('$compile')(
           '<div>' +
             'include: <ng:include src="\'includePartial.html\'"> </ng:include>' +
           '</div>')(myApp);
@@ -512,8 +512,8 @@ describe("widget", function() {
     }));
 
     it('should initialize view template after the view controller was initialized even when ' +
-       'templates were cached', inject(function($rootScope, $location, $browser, $route) {
-      // this is a test for a regression that was introduced by making the ng:view cache sync
+       'templates were cached', inject(function($rootScope, $compile, $location, $browser, $route) {
+      //this is a test for a regression that was introduced by making the ng:view cache sync
 
       $route.when('/foo', {controller: ParentCtrl, template: 'viewPartial.html'});
 
@@ -576,8 +576,8 @@ describe("widget", function() {
 
     describe('deal with pluralized strings without offset', function() {
        var element;
-       beforeEach(inject(function($rootScope) {
-          element = angular.compile(
+       beforeEach(inject(function($rootScope, $compile) {
+          element = $compile(
             '<ng:pluralize count="email"' +
                            "when=\"{'0': 'You have no new email'," +
                                    "'one': 'You have one new email'," +
@@ -585,7 +585,7 @@ describe("widget", function() {
             '</ng:pluralize>')($rootScope);
         }));
 
-        it('should show single/plural strings', inject(function($rootScope) {
+        it('should show single/plural strings', inject(function($rootScope, $compile) {
           $rootScope.email = 0;
           $rootScope.$digest();
           expect(element.text()).toBe('You have no new email');
@@ -624,7 +624,7 @@ describe("widget", function() {
         }));
 
 
-        it('should show single/plural strings with mal-formed inputs', inject(function($rootScope) {
+        it('should show single/plural strings with mal-formed inputs', inject(function($rootScope, $compile) {
           $rootScope.email = '';
           $rootScope.$digest();
           expect(element.text()).toBe('');
@@ -665,8 +665,8 @@ describe("widget", function() {
 
 
     describe('deal with pluralized strings with offset', function() {
-      it('should show single/plural strings with offset', inject(function($rootScope) {
-        var element = angular.compile(
+      it('should show single/plural strings with offset', inject(function($rootScope, $compile) {
+        var element = $compile(
           "<ng:pluralize count=\"viewCount\"  offset=2 " +
               "when=\"{'0': 'Nobody is viewing.'," +
                       "'1': '{{p1}} is viewing.'," +
-- 
cgit v1.2.3