Parent and FullName in DynamicClass

ajlopez · Nov 30, 2013 · 10cf0ed · 10cf0ed
1 parent 5da49ce
commit 10cf0ed
Show file tree

Hide file tree

Showing 6 changed files with 44 additions and 42 deletions.
diff --git a/Src/RubySharp.Core.Tests/EvaluateTests.cs b/Src/RubySharp.Core.Tests/EvaluateTests.cs
@@ -458,7 +458,8 @@ public void DefineQualifiedClass()
 
             Assert.IsNotNull(result);
             Assert.IsInstanceOfType(result, typeof(DynamicClass));
-            Assert.AreEqual("MyModule::MyClass", ((DynamicClass)result).Name);
+            Assert.AreEqual("MyClass", ((DynamicClass)result).Name);
+            Assert.AreEqual("MyModule::MyClass", ((DynamicClass)result).FullName);
         }
 
         [TestMethod]

diff --git a/Src/RubySharp.Core.Tests/Expressions/ModuleExpressionTests.cs b/Src/RubySharp.Core.Tests/Expressions/ModuleExpressionTests.cs
@@ -86,7 +86,8 @@ public void EvaluateModuleExpressionWithClassDefinition()
 
             Assert.IsNotNull(@class);
             Assert.IsInstanceOfType(@class, typeof(DynamicClass));
-            Assert.AreEqual("Module1::Foo", ((DynamicClass)@class).Name);
+            Assert.AreEqual("Foo", ((DynamicClass)@class).Name);
+            Assert.AreEqual("Module1::Foo", ((DynamicClass)@class).FullName);
         }
 
         [TestMethod]

diff --git a/Src/RubySharp.Core.Tests/MachineFileTests.cs b/Src/RubySharp.Core.Tests/MachineFileTests.cs
@@ -193,11 +193,13 @@ public void ExecuteModuleWithClassesFile()
 
             Assert.IsNotNull(result1);
             Assert.IsInstanceOfType(result1, typeof(DynamicClass));
-            Assert.AreEqual("MyLisp::List", ((DynamicClass)result1).Name);
+            Assert.AreEqual("List", ((DynamicClass)result1).Name);
+            Assert.AreEqual("MyLisp::List", ((DynamicClass)result1).FullName);
 
             Assert.IsNotNull(result2);
             Assert.IsInstanceOfType(result2, typeof(DynamicClass));
-            Assert.AreEqual("MyLisp::Atom", ((DynamicClass)result2).Name);
+            Assert.AreEqual("Atom", ((DynamicClass)result2).Name);
+            Assert.AreEqual("MyLisp::Atom", ((DynamicClass)result2).FullName);
         }
 
         [TestMethod]
@@ -211,10 +213,12 @@ public void ExecuteClassWithModuleFile()
             Assert.IsNotNull(result1);
             Assert.IsInstanceOfType(result1, typeof(DynamicClass));
             Assert.AreEqual("MyClass", ((DynamicClass)result1).Name);
+            Assert.AreEqual("MyClass", ((DynamicClass)result1).FullName);
 
             Assert.IsNotNull(result2);
             Assert.IsInstanceOfType(result2, typeof(DynamicClass));
-            Assert.AreEqual("MyClass::MyModule", ((DynamicClass)result2).Name);
+            Assert.AreEqual("MyModule", ((DynamicClass)result2).Name);
+            Assert.AreEqual("MyClass::MyModule", ((DynamicClass)result2).FullName);
         }
 
         [TestMethod]
@@ -232,11 +236,13 @@ public void ExecuteNestedModulesFile()
 
             Assert.IsNotNull(result2);
             Assert.IsInstanceOfType(result2, typeof(DynamicClass));
-            Assert.AreEqual("MyModule::MySubmodule", ((DynamicClass)result2).Name);
+            Assert.AreEqual("MySubmodule", ((DynamicClass)result2).Name);
+            Assert.AreEqual("MyModule::MySubmodule", ((DynamicClass)result2).FullName);
 
             Assert.IsNotNull(result3);
             Assert.IsInstanceOfType(result3, typeof(DynamicClass));
-            Assert.AreEqual("MyModule::MySubmodule::MySubmodule2", ((DynamicClass)result3).Name);
+            Assert.AreEqual("MySubmodule2", ((DynamicClass)result3).Name);
+            Assert.AreEqual("MyModule::MySubmodule::MySubmodule2", ((DynamicClass)result3).FullName);
         }
 
         [TestMethod]

diff --git a/Src/RubySharp.Core/Expressions/ClassExpression.cs b/Src/RubySharp.Core/Expressions/ClassExpression.cs
@@ -54,33 +54,19 @@ public object Evaluate(Context context)
             if (value == null || !(value is DynamicClass))
             {
                 var classclass = (DynamicClass)context.RootContext.GetLocalValue("Class");
-                var objectclass = (DynamicClass)context.RootContext.GetLocalValue("Object");
-                var newclass = new DynamicClass(classclass, this.namedexpression.Name, objectclass);
-
-                if (target == null)
-                {
-                    if (context.Module != null)
-                    {
-                        newclass.Name = context.Module.Name + "::" + this.namedexpression.Name;
-                        context.Module.Constants.SetLocalValue(this.namedexpression.Name, newclass);
-                    }
-                    else
-                    {
-                        newclass.Name = this.namedexpression.Name;
-                        context.RootContext.SetLocalValue(this.namedexpression.Name, newclass);
-                    }
-                }
-                else
-                {
-                    newclass.Name = target.Name + "::" + this.namedexpression.Name;
-                    target.Constants.SetLocalValue(this.namedexpression.Name, newclass);
-                }
+                var superclass = (DynamicClass)context.RootContext.GetLocalValue("Object");
+                string name = this.namedexpression.Name;
+                var parent = target == null ? context.Module : target;
 
                 if (this.superclassexpression != null)
-                {
-                    var superclass = (DynamicClass)this.superclassexpression.Evaluate(context);
-                    newclass.SetSuperClass(superclass);
-                }
+                    superclass = (DynamicClass)this.superclassexpression.Evaluate(context);
+
+                var newclass = new DynamicClass(classclass, name, superclass, parent);
+
+                if (parent == null)
+                    context.RootContext.SetLocalValue(name, newclass);
+                else
+                    parent.Constants.SetLocalValue(name, newclass);
 
                 value = newclass;
             }

diff --git a/Src/RubySharp.Core/Expressions/ModuleExpression.cs b/Src/RubySharp.Core/Expressions/ModuleExpression.cs
@@ -36,18 +36,13 @@ public object Evaluate(Context context)
             if (value == null || !(value is DynamicClass))
             {
                 DynamicClass modclass = (DynamicClass)context.RootContext.GetLocalValue("Module");
-                module = new DynamicClass(modclass, this.name);
+                var superclass = (DynamicClass)context.RootContext.GetLocalValue("Object");
+                module = new DynamicClass(modclass, this.name, superclass, context.Module);
 
                 if (context.Module != null)
-                {
-                    module.Name = context.Module.Name + "::" + this.name;
                     context.Module.Constants.SetLocalValue(this.name, module);
-                }
                 else
-                {
-                    module.Name = this.name;
                     context.RootContext.SetLocalValue(this.name, module);
-                }
             }
             else
                 module = (DynamicClass)value;

diff --git a/Src/RubySharp.Core/Language/DynamicClass.cs b/Src/RubySharp.Core/Language/DynamicClass.cs
@@ -12,6 +12,7 @@ public class DynamicClass : DynamicObject
 
         private string name;
         private DynamicClass superclass;
+        private DynamicClass parent;
         private IDictionary<string, IFunction> methods = new Dictionary<string, IFunction>();
         private Context constants = new Context();
 
@@ -20,19 +21,31 @@ public DynamicClass(string name, DynamicClass superclass = null)
         {
         }
 
-        public DynamicClass(DynamicClass @class, string name, DynamicClass superclass = null)
+        public DynamicClass(DynamicClass @class, string name, DynamicClass superclass = null, DynamicClass parent = null)
             : base(@class)
         {
             this.name = name;
             this.superclass = superclass;
+            this.parent = parent;
         }
 
-        public string Name { get { return this.name; } internal set { this.name = value; } }
+        public string Name { get { return this.name; } }
 
         public DynamicClass SuperClass { get { return this.superclass; } }
 
         public Context Constants { get { return this.constants; } }
 
+        public string FullName
+        {
+            get
+            {
+                if (this.parent == null)
+                    return this.Name;
+
+                return this.parent.FullName + "::" + this.Name;
+            }
+        }
+
         public void SetInstanceMethod(string name, IFunction method)
         {
             this.methods[name] = method;
@@ -66,7 +79,7 @@ public IList<string> GetOwnInstanceMethodNames()
 
         public override string ToString()
         {
-            return this.Name;
+            return this.FullName;
         }
 
         internal void SetSuperClass(DynamicClass superclass)