Further embedding of Ruby as implementation detail

Interfaces themselves as language agnostic

--HG--
branch : dev
extra : rebase_source : d15b587bafec98d49b322ba2dd8ad0f493798563

src/Orchard.Core.Tests/Body/BodyPartTests.cs

@@ -86,8 +86,6 @@ namespace Orchard.Core.Tests.Body {
         }
 
         public class Thing : ContentPart {
-            public int Id { get { return ContentItem.Id; } }
-
             public string Text {
                 get { return this.As<BodyPart>().Text; }
                 set { this.As<BodyPart>().Text = value; }

src/Orchard.Core.Tests/Routable/Services/RoutableServiceTests.cs

@@ -208,8 +208,6 @@ namespace Orchard.Core.Tests.Routable.Services {
         }
 
         public class Thing : ContentPart {
-            public int Id { get { return ContentItem.Id; } }
-
             public string Title {
                 get { return this.As<RoutePart>().Title; }
                 set { this.As<RoutePart>().Title = value; }
@@ -232,8 +230,6 @@ namespace Orchard.Core.Tests.Routable.Services {
         }
 
         public class Stuff : ContentPart {
-            public int Id { get { return ContentItem.Id; } }
-
             public string Title {
                 get { return this.As<RoutePart>().Title; }
                 set { this.As<RoutePart>().Title = value; }

src/Orchard.Tests/Scripting/ScriptingTests.cs

@@ -36,11 +36,12 @@ namespace Orchard.Tests.Scripting {
         }
 
         [Test]
-        public void GetRubyEngineReturnsAWorkingRubyEngine() {
+        public void CreateScopeReturnsWorkingScope() {
-            var ruby = _scriptingRuntime.GetRubyEngine();
+            var scope = _scriptingRuntime.CreateScope();
 
-            Assert.IsNotNull(ruby);
+            Assert.IsNotNull(scope);
-            Assert.That(ruby.Execute("21 + 21"), Is.EqualTo(42));
+            scope.SetVariable("alpha", 42);
+            Assert.That(scope.GetVariable("alpha"), Is.EqualTo(42));
         }
 
         [Test]
@@ -52,7 +53,7 @@ namespace Orchard.Tests.Scripting {
         [Test]
         public void ScriptingManagerCanEvalExpression() {
             _scriptingManager.SetVariable("foo", 21);
-            Assert.That(_scriptingManager.Eval("foo + 21"), Is.EqualTo(42));
+            Assert.That(_scriptingManager.ExecuteExpression("foo + 21"), Is.EqualTo(42));
         }
 
         [Test]
@@ -63,8 +64,8 @@ namespace Orchard.Tests.Scripting {
             scriptManager1.SetVariable("foo", 1);
             scriptManager2.SetVariable("foo", 2);
 
-            var result1 = scriptManager1.Eval("3 + foo");
+            var result1 = scriptManager1.ExecuteExpression("3 + foo");
-            var result2 = scriptManager2.Eval("3 + foo");
+            var result2 = scriptManager2.ExecuteExpression("3 + foo");
 
             Assert.That(result1, Is.EqualTo(4));
             Assert.That(result2, Is.EqualTo(5));
@@ -75,23 +76,15 @@ namespace Orchard.Tests.Scripting {
             var targetPath = Path.Combine(_tempFolderName, "SampleMethodDefinition.rb");
             File.WriteAllText(targetPath, "def f\r\nreturn 32\r\nend\r\n");
             _scriptingManager.ExecuteFile(targetPath);
-            Assert.That(_scriptingManager.Eval("f / 4"), Is.EqualTo(8));
+            Assert.That(_scriptingManager.ExecuteExpression("f / 4"), Is.EqualTo(8));
         }
 
-        [Test]
-        public void GlobalObjectCanBeDynamic() {
-            dynamic global = new Clay(new PropBehavior());
-            _scriptingManager.SetScriptingScope(_scriptingRuntime.GetRubyEngine().CreateScope((IDynamicMetaObjectProvider)global));
-            
-            global.foo = 5;
-            Assert.That(_scriptingManager.Eval("3 + foo"), Is.EqualTo(8));
-        }
 
         [Test]
         public void CanDeclareCallbackOnGlobalMethod() {
             _scriptingManager.SetVariable("x", new Clay(new ReturnMethodNameLengthBehavior()));
 
-            Assert.That(_scriptingManager.Eval("3 + x.foo()"), Is.EqualTo(6));
+            Assert.That(_scriptingManager.ExecuteExpression("3 + x.foo()"), Is.EqualTo(6));
         }
 
 
@@ -109,7 +102,7 @@ namespace Orchard.Tests.Scripting {
             _scriptingManager.ExecuteFile(targetPath);
             _scriptingManager.SetVariable("callbacks", new CallbackApi());
 
-            Assert.That(_scriptingManager.Eval("execute { 1 + hello + world('yep') }"), Is.EqualTo(11));
+            Assert.That(_scriptingManager.ExecuteExpression("execute { 1 + hello + world('yep') }"), Is.EqualTo(11));
         }
 
         public class CallbackApi {

src/Orchard.Web/Core/Localization/Models/LocalizationPart.cs

@@ -11,9 +11,6 @@ namespace Orchard.Core.Localization.Models {
         public LazyField<CultureRecord> CultureField { get { return _culture; } }
         public LazyField<IContent> MasterContentItemField { get { return _masterContentItem; } }
 
-        [HiddenInput(DisplayValue = false)]
-        public int Id { get { return ContentItem.Id; } }
-
         public CultureRecord Culture {
             get { return _culture.Value; }
             set { _culture.Value = value; }

src/Orchard.Web/Core/Navigation/Models/MenuItemPart.cs

@@ -4,9 +4,6 @@ using Orchard.ContentManagement;
 
 namespace Orchard.Core.Navigation.Models {
     public class MenuItemPart : ContentPart<MenuItemPartRecord> {
-        [HiddenInput(DisplayValue = false)]
-        public int Id { get { return ContentItem.Id; } }
-
         [Required]
         public string Url {
             get { return Record.Url; }

src/Orchard.Web/Core/Navigation/Models/MenuPart.cs

@@ -4,8 +4,6 @@ using Orchard.ContentManagement;
 
 namespace Orchard.Core.Navigation.Models {
     public class MenuPart : ContentPart<MenuPartRecord> {
-        [HiddenInput(DisplayValue = false)]
-        public int Id { get { return ContentItem.Id; } }
 
         public bool OnMainMenu {
             get { return Record.OnMainMenu; }

src/Orchard.Web/Modules/Orchard.Blogs/Models/BlogPart.cs

@@ -4,9 +4,6 @@ using Orchard.Core.Routable.Models;
 
 namespace Orchard.Blogs.Models {
     public class BlogPart : ContentPart<BlogPartRecord> {
-        [HiddenInput(DisplayValue = false)]
-        public int Id { get { return ContentItem.Id; } }
-
         public string Name {
             get { return this.As<RoutePart>().Title; }
             set { this.As<RoutePart>().Title = value; }

src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/RuleManager.cs

@@ -15,7 +15,7 @@ namespace Orchard.Widgets.RuleEngine {
 
         public bool Matches(string expression) {
             _scriptingManager.SetVariable("callbacks", new CallbackApi(this));
-            dynamic execContext = _scriptingManager.Eval(@"
+            dynamic execContext = _scriptingManager.ExecuteExpression(@"
                                         class ExecContext
 	                                        def initialize(callbacks)
 		                                        @callbacks = callbacks;

src/Orchard/Scripting/IScriptingManager.cs

@@ -1,11 +1,8 @@
-using Microsoft.Scripting.Hosting;
+namespace Orchard.Scripting {
-
-namespace Orchard.Scripting {
     public interface IScriptingManager : IDependency {
         dynamic GetVariable(string name);
         void SetVariable(string name, object value);
-        dynamic Eval(string expression);
+        dynamic ExecuteExpression(string expression);
         void ExecuteFile(string fileName);
-        void SetScriptingScope(ScriptScope scriptScope);
     }
 }

src/Orchard/Scripting/IScriptingRuntime.cs

@@ -2,6 +2,8 @@
 
 namespace Orchard.Scripting {
     public interface IScriptingRuntime : ISingletonDependency {
-        ScriptEngine GetRubyEngine();
+        ScriptScope CreateScope();
+        dynamic ExecuteExpression(string expression, ScriptScope scope);
+        void ExecuteFile(string fileName, ScriptScope scope);
     }
 }

src/Orchard/Scripting/ScriptingManager.cs

@@ -1,38 +1,31 @@
-using Microsoft.Scripting.Hosting;
+using System;
+using Microsoft.Scripting.Hosting;
 
 namespace Orchard.Scripting {
     public class ScriptingManager : IScriptingManager {
         private readonly IScriptingRuntime _scriptingRuntime;
-        private ScriptScope _scriptingScope;
+        private Lazy<ScriptScope> _scope;
 
         public ScriptingManager(IScriptingRuntime scriptingRuntime) {
             _scriptingRuntime = scriptingRuntime;
-            _scriptingScope = _scriptingRuntime.GetRubyEngine().CreateScope();
+            _scope = new Lazy<ScriptScope>(()=>_scriptingRuntime.CreateScope());
         }
 
-        #region IScriptingContext Members
-
         public dynamic GetVariable(string name) {
-            return _scriptingScope.GetVariable(name);
+            return _scope.Value.GetVariable(name);
         }
 
         public void SetVariable(string name, object value) {
-            _scriptingScope.SetVariable(name, value);
+            _scope.Value.SetVariable(name, value);
         }
 
-        public dynamic Eval(string expression) {
+        public dynamic ExecuteExpression(string expression) {
-            var script = _scriptingRuntime.GetRubyEngine().CreateScriptSourceFromString(expression);
+            return _scriptingRuntime.ExecuteExpression(expression, _scope.Value);
-            return script.Execute(_scriptingScope);
         }
 
         public void ExecuteFile(string fileName) {
-            _scriptingRuntime.GetRubyEngine().ExecuteFile(fileName, _scriptingScope);
+            _scriptingRuntime.ExecuteFile(fileName, _scope.Value);
         }
 
-        public void SetScriptingScope(ScriptScope scriptScope) {
-            _scriptingScope = scriptScope;
-        }
-
-        #endregion
     }
 }

src/Orchard/Scripting/ScriptingRuntime.cs

@@ -3,16 +3,34 @@ using Microsoft.Scripting.Hosting;
 
 namespace Orchard.Scripting {
     public class ScriptingRuntime : IScriptingRuntime {
+        private readonly LanguageSetup _defaultLanguageSetup;
         private readonly ScriptRuntime _scriptingRuntime;
 
         public ScriptingRuntime() {
+            _defaultLanguageSetup = Ruby.CreateRubySetup();
+
             var setup = new ScriptRuntimeSetup();
-            setup.LanguageSetups.Add(Ruby.CreateRubySetup());
+            setup.LanguageSetups.Add(_defaultLanguageSetup);
             _scriptingRuntime = new ScriptRuntime(setup);
         }
 
-        public ScriptEngine GetRubyEngine() {
+        ScriptEngine GetDefaultEngine() {
-            return _scriptingRuntime.GetEngine("ruby");
+            return _scriptingRuntime.GetEngineByTypeName(_defaultLanguageSetup.TypeName);
+        }
+
+        public ScriptScope CreateScope() {
+            return _scriptingRuntime.CreateScope();
+        }
+
+        public dynamic ExecuteExpression(string expression, ScriptScope scope) {
+            var engine = GetDefaultEngine();
+            var source = engine.CreateScriptSourceFromString(expression);
+            return source.Execute(scope);
+        }
+
+        public void ExecuteFile(string fileName, ScriptScope scope) {
+            var engine = GetDefaultEngine();
+            engine.ExecuteFile(fileName, scope);
         }
     }
 }

src/Orchard/Security/IUser.cs

@@ -5,7 +5,6 @@ namespace Orchard.Security {
     /// Interface provided by the "User" model. 
     /// </summary>
     public interface IUser : IContent {
-        int Id { get; }
         string UserName { get; }
         string Email { get; }
     }