Separate parts of modlib into two files. See #3

Author: scrlys

modloader/modast.py

@@ -3,6 +3,7 @@
 This file is free software under the GPLv3 license
 """
 import os
+import string
 
 import renpy
 from renpy import ast
@@ -204,3 +205,140 @@ def find_python_statement(statement):
         if isinstance(node, ast.Python) and node.code.source == statement:
             return node
     return None
+
+ROT13 = string.maketrans(
+    "NOPQRSTUVWXYZnopqrstuvwxyzABCDEFGHIJKLMabcdefghijklm",
+    "ABCDEFGHIJKLMabcdefghijklmNOPQRSTUVWXYZnopqrstuvwxyz")
+
+class ASTHook(ast.Node):
+    """A custom :class:`renpy.ast.Node` that acts as a hook between
+        other node objects.
+
+    Note:
+        Don't instantiate this class directly. Ren'Py uses an
+        internal serial for the call stack and other uses. This
+        class emulates that at the base class.
+
+    Attributes:
+        hook_func: A function that's called when the node is executed.
+                If the function returns a non-None value, the next
+                node will be skipped.
+        fromOp: Unknown
+        __oldNext: The original next node before hooking was done
+    """
+    def __init__(self, loc, hook_func=None, from_op=None):
+        #TODO: Understand fromOp and __oldNext
+        super(ASTHook, self).__init__(loc)
+
+        self.hook_func = hook_func
+        self.from_op = from_op
+        self.old_next = None
+
+    def execute(self):
+        """Execute hook after node is called"""
+        ast.statement_name("hook")
+        ret = None
+        if self.hook_func:
+            ret = self.hook_func(self)
+        if not ret:
+            self.exec_continue()
+
+    def exec_continue(self):
+        """Continue"""
+        ast.next_node(self.next)
+
+    def unhook(self):
+        """Remove the hook"""
+        self.from_op.next = self.old_next
+
+
+class MenuHook(object):
+    """A hook class for editing a specific menu"""
+
+    def __init__(self, menu_, base_):
+        """Make a hook class for the specific ``menu_`` object
+
+        Args:
+            menu_ (renpy.ast.Menu): The Menu node to be hooked
+            base_ (AWSWModBase): An instance of the mod base class
+        """
+        if not isinstance(menu_, ast.Menu):
+            raise AssertionError("MenuHook not instantiated with a Menu node!")
+
+        self.menu = menu_
+        self.base = base_
+        # Copy the menu.items list, not a reference to it
+        self.old_items = menu_.items[:]
+
+    def delete_item(self, item):
+        """Delete an item from the menu"""
+        # TODO: Describe what the hell is happening here.
+        self.get_items()[:] = [(lab, cond, block) for _, (lab, cond, block)
+                               in enumerate(self.get_items()) if lab != item]
+        return None
+
+    def get_item(self, item):
+        """Get an item from the menu"""
+        for obj in self.get_items():
+            if obj[0] == item:
+                return obj
+
+    def get_option_code(self, item):
+        """Get an item's SL code from the menu"""
+        obj = self.get_item(item)
+        return obj[2]
+
+    def get_items(self):
+        """Get all the items in the menu"""
+        return self.menu.items
+
+    def set_conditional(self, item, new_cond):
+        """Change the conditional statement for ``item``
+
+        Returns:
+            True if successful and False if not
+        """
+        for i, (lab, _, block) in enumerate(self.get_items()):
+            if lab == item:
+                self.menu.items[i] = (lab, new_cond, block)
+                return True
+        return False
+
+    def add_item(self, label, hook, condition="True"):
+        """Add a new item to the menu
+
+        Args:
+            label (str): The option's label
+
+            hook: Either a :class:`renpy.ast.Node` or a function to be
+                    executed after the menu choice has been selected
+
+            condition (str): A Python string to evaluate to determine
+                    whether or not the choice should be shown
+
+        Returns:
+            None if ``hook`` is a :class:`renpy.ast.Node` or a
+            :class:`ASTHook` if ``hook`` is a function
+        """
+        if isinstance(hook, ast.Node):
+            self.get_items().append((label, condition, [hook])) # Adding a dialogue option.
+            return None
+        else:
+            node = ASTHook(("AWSWMod", 1))
+            node.from_op = self.menu
+            node.hook_func = hook
+            node.name = "AWSWModOp_" + str(self.base.name_serial)
+            self.base.name_serial += 1
+            self.get_items().append((label, condition, [node]))
+            return node
+
+    def add_item_call(self, label, usr_hook, condition="True"):
+        #TODO: Determine what this does
+        # pylint: disable=missing-docstring, invalid-name
+        hook = self.add_item(label, None, condition)
+
+        def call_func(hook):
+            rv = renpy.game.context().call(usr_hook.name, return_site=self.menu.next.name)
+            hook.chain(rv)
+
+        hook.hook_func = call_func

modloader/modlib.py renamed to modloader/modgame.py

@@ -13,61 +13,10 @@
 import modloader
 from modloader import modast
 
-def sprnt(str_):
-    """Print an encoded string to stdout
-
-    Encode the string in UTF-8 before printing it out to stdout
-    This helps avoid Unicode errors
-
-    Args:
-        string (str): The string to be printed
-    """
-    print str_.encode('utf-8')
-
 ROT13 = string.maketrans(
     "NOPQRSTUVWXYZnopqrstuvwxyzABCDEFGHIJKLMabcdefghijklm",
     "ABCDEFGHIJKLMabcdefghijklmNOPQRSTUVWXYZnopqrstuvwxyz")
 
-class ASTHook(ast.Node):
-    """A custom :class:`renpy.ast.Node` that acts as a hook between
-        other node objects.
-
-    Note:
-        Don't instantiate this class directly. Ren'Py uses an
-        internal serial for the call stack and other uses. This
-        class emulates that at the base class.
-
-    Attributes:
-        hook_func: A function that's called when the node is executed.
-                If the function returns a non-None value, the next
-                node will be skipped.
-        fromOp: Unknown
-        __oldNext: The original next node before hooking was done
-    """
-    def __init__(self, loc, hook_func=None, from_op=None):
-        #TODO: Understand fromOp and __oldNext
-        super(ASTHook, self).__init__(loc)
-
-        self.hook_func = hook_func
-        self.from_op = from_op
-        self.old_next = None
-
-    def execute(self):
-        """Execute hook after node is called"""
-        ast.statement_name("hook")
-        ret = None
-        if self.hook_func:
-            ret = self.hook_func(self)
-        if not ret:
-            self.exec_continue()
-
-    def exec_continue(self):
-        """Continue"""
-        ast.next_node(self.next)
-
-    def unhook(self):
-        """Remove the hook"""
-        self.from_op.next = self.old_next
 
 class AWSWEndingHooks(object):
     """The ending hooks for the game"""
@@ -132,97 +81,6 @@ def get_ending_picker_menu(self):
         return menu_hooks
 
 
-class AWSWMenuHook(object):
-    """A hook class for editing a specific menu"""
-
-    def __init__(self, menu_, base_):
-        """Make a hook class for the specific ``menu_`` object
-
-        Args:
-            menu_ (renpy.ast.Menu): The Menu node to be hooked
-            base_ (AWSWModBase): An instance of the mod base class
-        """
-        if not isinstance(menu_, ast.Menu):
-            raise AssertionError("MenuHook not instantiated with a Menu node!")
-
-        self.menu = menu_
-        self.base = base_
-        # Copy the menu.items list, not a reference to it
-        self.old_items = menu_.items[:]
-
-    def delete_item(self, item):
-        """Delete an item from the menu"""
-        # TODO: Describe what the hell is happening here.
-        self.get_items()[:] = [(lab, cond, block) for _, (lab, cond, block)
-                               in enumerate(self.get_items()) if lab != item]
-        return None
-
-    def get_item(self, item):
-        """Get an item from the menu"""
-        for obj in self.get_items():
-            if obj[0] == item:
-                return obj
-
-    def get_option_code(self, item):
-        # pylint: disable=missing-docstring
-        obj = self.get_item(item)
-        return obj[2]
-
-    def get_items(self):
-        """Get all the items in the menu"""
-        return self.menu.items
-
-    def set_conditional(self, item, new_cond):
-        """Change the conditional statement for ``item``
-
-        Returns:
-            True if successful and False if not
-        """
-        for i, (lab, _, block) in enumerate(self.get_items()):
-            if lab == item:
-                self.menu.items[i] = (lab, new_cond, block)
-                return True
-        return False
-
-    def add_item(self, label, hook, condition="True"):
-        """Add a new item to the menu
-
-        Args:
-            label (str): The option's label
-
-            hook: Either a :class:`renpy.ast.Node` or a function to be
-                    executed after the menu choice has been selected
-
-            condition (str): A Python string to evaluate to determine
-                    whether or not the choice should be shown
-
-        Returns:
-            None if ``hook`` is a :class:`renpy.ast.Node` or a
-            :class:`ASTHook` if ``hook`` is a function
-        """
-        if isinstance(hook, ast.Node):
-            self.get_items().append((label, condition, [hook])) # Adding a dialogue option.
-            return None
-        else:
-            node = ASTHook(("AWSWMod", 1))
-            node.from_op = self.menu
-            node.hook_func = hook
-            node.name = "AWSWModOp_" + str(self.base.name_serial)
-            self.base.name_serial += 1
-            self.get_items().append((label, condition, [node]))
-            return node
-
-    def add_item_call(self, label, usr_hook, condition="True"):
-        #TODO: Determine what this does
-        # pylint: disable=missing-docstring, invalid-name
-        hook = self.add_item(label, None, condition)
-
-        def call_func(hook):
-            rv = renpy.game.context().call(usr_hook.name, return_site=self.menu.next.name)
-            hook.chain(rv)
-
-        hook.hook_func = call_func
-
 class AWSWHomeHook(object):
     """Hook the menu found in the player's apartment."""
 
@@ -417,7 +275,7 @@ def hook_opcode(self, node, func):
         """
         next_statement = node.next
 
-        hook = ASTHook(("AWSWMod", 1)) # hooking hooks breaks
+        hook = modast.ASTHook(("AWSWMod", 1)) # hooking hooks breaks
         hook.from_op = node
         node.next = hook
         hook.chain(next_statement)
@@ -495,7 +353,7 @@ def unhooklabel(self, label):
         #TODO: Determine if method should be a static function
         # pylint: disable=no-self-use
         found_node = modast.find_label(label)
-        if isinstance(found_node, ASTHook):
+        if isinstance(found_node, modast.ASTHook):
             found_node.from_op.next = found_node.next
 
     def disable_slast_cache(self):
@@ -518,7 +376,7 @@ def get_menu_hook(self, menu):
         """
         #TODO: Determine whether method should be static function
         # pylint: disable=no-self-use
-        return AWSWMenuHook(menu, base)
+        return modast.MenuHook(menu, base)
 
     def get_home_hook(self):
         """Get the home hook class
@@ -547,7 +405,7 @@ def get_node_from_location(self, node, location):
             node = node.next
 
             # Effectively skip the ASTHook nodes by continuing on
-            while node and isinstance(node, ASTHook):
+            while node and isinstance(node, modast.ASTHook):
                 node = node.next
         return node