remove useless get_ prefixes

4 files changed, 49 insertions, 49 deletions

diff --git a/t/__init__.py b/t/__init__.py
index a714b9e..fdbb1aa 100644
--- a/t/__init__.py
+++ b/t/__init__.py
@@ -9,10 +9,10 @@ class InMemoryDatabase(object):
         self.class_registry = {}
 
     def register_class(self, c):
-        self.class_registry[c.get_name()] = c
+        self.class_registry[c.name()] = c
 
     def insert(self, name, obj):
-        data = self._get_repr(obj)
+        data = self._repr(obj)
         self.store[name] = json.dumps(
             data,
             separators=(',', ':'),
@@ -32,7 +32,7 @@ class InMemoryDatabase(object):
         else:
             raise Exception("object not in database")
 
-    def _get_repr(self, obj):
+    def _repr(self, obj):
         if type(obj) == type([]):
             return { "type": "plain", "data": obj }
         if type(obj) == type({}):
@@ -49,7 +49,7 @@ class InMemoryDatabase(object):
             self.register_class(obj.metaclass)
             return {
                 "type": "object",
-                "class": obj.metaclass.get_name(),
+                "class": obj.metaclass.name(),
                 "data": obj.slots,
             }
         raise Exception("unknown object type")
diff --git a/t/database_test.py b/t/database_test.py
index bd278c2..696b649 100644
--- a/t/database_test.py
+++ b/t/database_test.py
@@ -32,11 +32,11 @@ class DatabaseTest(unittest.TestCase):
         Point.add_attribute(Point.attribute_class().new(name="y"))
         Point.add_method(Point.method_class().new(
             name="x",
-            body=lambda self: self.metaclass.get_all_attributes()["x"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["x"].value(self)
         ))
         Point.add_method(Point.method_class().new(
             name="y",
-            body=lambda self: self.metaclass.get_all_attributes()["y"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["y"].value(self)
         ))
         Point.finalize()
 
diff --git a/t/mop_test.py b/t/mop_test.py
index b511163..f48d041 100644
--- a/t/mop_test.py
+++ b/t/mop_test.py
@@ -19,28 +19,28 @@ class MopTest(unittest.TestCase):
         assert mop.Object.isa(mop.Object)
         assert mop.Object.isa(mop.Class)
 
-        assert mop.Class.get_all_methods()["add_method"].isa(mop.Object)
-        assert mop.Class.get_all_methods()["add_method"].isa(mop.Method)
-        assert not mop.Class.get_all_methods()["add_method"].isa(mop.Class)
+        assert mop.Class.all_methods()["add_method"].isa(mop.Object)
+        assert mop.Class.all_methods()["add_method"].isa(mop.Method)
+        assert not mop.Class.all_methods()["add_method"].isa(mop.Class)
 
-        assert mop.Class.get_all_attributes()["superclass"].isa(mop.Object)
-        assert mop.Class.get_all_attributes()["superclass"].isa(mop.Attribute)
-        assert not mop.Class.get_all_attributes()["superclass"].isa(mop.Class)
+        assert mop.Class.all_attributes()["superclass"].isa(mop.Object)
+        assert mop.Class.all_attributes()["superclass"].isa(mop.Attribute)
+        assert not mop.Class.all_attributes()["superclass"].isa(mop.Class)
 
-        assert mop.Class.get_name() == "Class"
-        assert mop.Object.get_name() == "Object"
-        assert mop.Method.get_name() == "Method"
-        assert mop.Attribute.get_name() == "Attribute"
+        assert mop.Class.name() == "Class"
+        assert mop.Object.name() == "Object"
+        assert mop.Method.name() == "Method"
+        assert mop.Attribute.name() == "Attribute"
 
-        assert mop.Class.get_superclass() is mop.Object
-        assert mop.Object.get_superclass() is None
-        assert mop.Method.get_superclass() is mop.Object
-        assert mop.Attribute.get_superclass() is mop.Object
+        assert mop.Class.superclass() is mop.Object
+        assert mop.Object.superclass() is None
+        assert mop.Method.superclass() is mop.Object
+        assert mop.Attribute.superclass() is mop.Object
 
-        assert mop.Class.get_mro() == [ mop.Class, mop.Object ]
-        assert mop.Object.get_mro() == [ mop.Object ]
-        assert mop.Method.get_mro() == [ mop.Method, mop.Object ]
-        assert mop.Attribute.get_mro() == [ mop.Attribute, mop.Object ]
+        assert mop.Class.mro() == [ mop.Class, mop.Object ]
+        assert mop.Object.mro() == [ mop.Object ]
+        assert mop.Method.mro() == [ mop.Method, mop.Object ]
+        assert mop.Attribute.mro() == [ mop.Attribute, mop.Object ]
 
     def test_class_creation(self):
         Point = mop.Class.new(
@@ -53,22 +53,22 @@ class MopTest(unittest.TestCase):
 
         Point.add_method(Point.method_class().new(
             name="x",
-            body=lambda self: self.metaclass.get_all_attributes()["x"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["x"].value(self)
         ))
         Point.add_method(Point.method_class().new(
             name="y",
-            body=lambda self: self.metaclass.get_all_attributes()["y"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["y"].value(self)
         ))
         Point.add_method(Point.method_class().new(
             name="set_x",
-            body=lambda self, new_value: self.metaclass.get_all_attributes()["x"].set_value(self, new_value)
+            body=lambda self, new_value: self.metaclass.all_attributes()["x"].set_value(self, new_value)
         ))
         Point.finalize()
 
         assert Point.metaclass is mop.Class
         assert Point.isa(mop.Object)
-        assert Point.get_superclass() is mop.Object
-        assert Point.get_mro() == [ Point, mop.Object ]
+        assert Point.superclass() is mop.Object
+        assert Point.mro() == [ Point, mop.Object ]
 
         point = Point.new(x=1, y=2)
         assert point.isa(Point)
@@ -92,14 +92,14 @@ class MopTest(unittest.TestCase):
         Point3D.add_attribute(Point3D.attribute_class().new(name="z", default=0))
         Point3D.add_method(Point3D.method_class().new(
             name="z",
-            body=lambda self: self.metaclass.get_all_attributes()["z"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["z"].value(self)
         ))
         Point3D.finalize()
 
         assert Point3D.metaclass is mop.Class
         assert Point3D.isa(mop.Object)
-        assert Point3D.get_superclass() is Point
-        assert Point3D.get_mro() == [ Point3D, Point, mop.Object ]
+        assert Point3D.superclass() is Point
+        assert Point3D.mro() == [ Point3D, Point, mop.Object ]
 
         point3d = Point3D.new(x=3, y=4, z=5)
         assert point3d.isa(Point3D)
diff --git a/t/overrides_test.py b/t/overrides_test.py
index dd20097..adf60b3 100644
--- a/t/overrides_test.py
+++ b/t/overrides_test.py
@@ -9,7 +9,7 @@ from . import InMemoryDatabase
 # obscure the implementation and make it not as easy to follow (we would have
 # to manage call stacks ourselves), and so we just do this instead for now
 def call_method_at_class(c, method_name, invocant, *args, **kwargs):
-    return c.get_all_methods()[method_name].slots["body"](
+    return c.all_methods()[method_name].slots["body"](
         invocant, *args, **kwargs
     )
 
@@ -20,11 +20,11 @@ class OverridesTest(unittest.TestCase):
             superclass=mop.Class,
         )
         def add_attribute(self, attr):
-            name = attr.get_name()
+            name = attr.name()
             call_method_at_class(mop.Class, "add_attribute", self, attr)
             self.add_method(self.method_class().new(
                 name=name,
-                body=lambda self: self.metaclass.get_all_attributes()[name].get_value(self),
+                body=lambda self: self.metaclass.all_attributes()[name].value(self),
             ))
         AccessorsMetaclass.add_method(AccessorsMetaclass.metaclass.method_class().new(
             name="add_attribute",
@@ -53,7 +53,7 @@ class OverridesTest(unittest.TestCase):
         )
 
         def execute(self, invocant, args, kwargs):
-            methods_called.append(self.get_name())
+            methods_called.append(self.name())
             return call_method_at_class(mop.Method, "execute", self, invocant, args, kwargs)
         TraceMethod.add_method(TraceMethod.metaclass.method_class().new(
             name="execute",
@@ -79,11 +79,11 @@ class OverridesTest(unittest.TestCase):
         Point.add_attribute(Point.attribute_class().new(name="y", default=0))
         Point.add_method(Point.method_class().new(
             name="x",
-            body=lambda self: self.metaclass.get_all_attributes()["x"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["x"].value(self)
         ))
         Point.add_method(Point.method_class().new(
             name="y",
-            body=lambda self: self.metaclass.get_all_attributes()["y"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["y"].value(self)
         ))
         Point.finalize()
 
@@ -104,17 +104,17 @@ class OverridesTest(unittest.TestCase):
         ))
         DatabaseAttribute.add_method(DatabaseAttribute.method_class().new(
             name="db",
-            body=lambda self: self.metaclass.get_all_attributes()["db"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["db"].value(self)
         ))
-        def get_value(self, instance):
-            key = str(instance.__hash__()) + ":" + self.get_name()
+        def value(self, instance):
+            key = str(instance.__hash__()) + ":" + self.name()
             return self.db().lookup(key)
         DatabaseAttribute.add_method(DatabaseAttribute.method_class().new(
-            name="get_value",
-            body=get_value,
+            name="value",
+            body=value,
         ))
         def set_value(self, instance, new_value):
-            key = str(instance.__hash__()) + ":" + self.get_name()
+            key = str(instance.__hash__()) + ":" + self.name()
             self.db().insert(key, new_value)
         DatabaseAttribute.add_method(DatabaseAttribute.method_class().new(
             name="set_value",
@@ -131,10 +131,10 @@ class OverridesTest(unittest.TestCase):
         ))
         DatabaseBackedClass.add_method(DatabaseBackedClass.method_class().new(
             name="db",
-            body=lambda self: self.metaclass.get_all_attributes()["db"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["db"].value(self)
         ))
         def add_attribute(self, attr):
-            attr.metaclass.get_all_attributes()["db"].set_value(attr, self.db())
+            attr.metaclass.all_attributes()["db"].set_value(attr, self.db())
             call_method_at_class(mop.Class, "add_attribute", self, attr)
         DatabaseBackedClass.add_method(DatabaseBackedClass.method_class().new(
             name="add_attribute",
@@ -155,15 +155,15 @@ class OverridesTest(unittest.TestCase):
         Point.add_attribute(Point.attribute_class().new(name="y", default=0))
         Point.add_method(Point.method_class().new(
             name="x",
-            body=lambda self: self.metaclass.get_all_attributes()["x"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["x"].value(self)
         ))
         Point.add_method(Point.method_class().new(
             name="y",
-            body=lambda self: self.metaclass.get_all_attributes()["y"].get_value(self)
+            body=lambda self: self.metaclass.all_attributes()["y"].value(self)
         ))
         Point.add_method(Point.method_class().new(
             name="set_x",
-            body=lambda self, new_value: self.metaclass.get_all_attributes()["x"].set_value(self, new_value)
+            body=lambda self, new_value: self.metaclass.all_attributes()["x"].set_value(self, new_value)
         ))
         Point.finalize()