28

class PageInfo (object) :

    29

    """

    30

        Contains metainformation about a page

    31

    """

    32

    33

    def __init__ (self, parent, name, title, children=None) :

    34

        """

    35

            Initialize, children defaults to empty list

    36

        """

    37

    38

        # store

    39

        self.parent = parent

    40

        self.name = name

    41

        self.title = title

    42

        self.children = children if children else []

    43

    44

        # no url get

    45

        self._url = None

    46

    47

    def set_parent (self, parent) :

    48

        """

    49

            Set a parent where non was set before

    50

        """

    51

    52

        assert self.parent is None

    53

    54

        self.parent = parent

    55

    56

    def add_child (self, child) :

    57

        """

    58

            Add a PageInfo child

    59

        """

    60

    61

        self.children.append(child)

    62

    63

    def get_child (self, name) :

    64

        """

    65

            Look up a child by name, returning None if not found

    66

        """

    67

    68

        return dict((c.name, c) for c in self.children).get(name)

    69

    70

    @property

    71

    def url (self) :

    72

        """

    73

            Build this page's URL

    74

        """

    75

    76

        # cached?

    77

        if self._url :

    78

            return self._url

    79

    80

        # collect URL segments in reverse order

    81

        segments = []

    82

    83

        # add empty segment if dir

    84

        if self.children :

    85

            segments.append('')

    86

    87

        # iterate over ancestry

    88

        item = self

    89

    90

        # add all parent names, but not root's

    91

        while item and item.parent :

    92

            segments.append(item.name)

    93

    94

            item = item.parent

    95

    96

        # reverse segments

    97

        segments.reverse()

    98

    99

        # join

   100

        url = '/'.join(segments)

   101

   102

        # cache

   103

        self._url = url

   104

   105

        # done

   106

        return url

   107

   108

class PageTree (object) :

   115

            Empty PageList, must call load_page_list to initialize, once

   118

    def _load (self, path=PAGE_LIST_FILE) :

   122

   123

        # collect the page list

   124

        pages = []

   125

   126

        # stack of (indent, PageInfo) items

   127

        stack = []

   128

   129

        # the previous item processed, None for first one

   130

        prev = None

   133

            indent = 0

   134

   135

            # count indent

   136

            for char in line :

   137

                # tabs break things

   138

                assert char != '\t'

   139

   140

                # increment up to first non-space char

   141

                if char == ' ' :

   142

                    indent += 1

   143

   144

                elif char == ':' :

   145

                    indent = 0

   146

                    break

   147

   148

                else :

   149

                    break

   150

   151

            # strip whitespace

   153

   161

            # remove whitespace

   162

            url = url.strip()

   163

            title = title.strip()

   164

   165

            # create PageInfo item without parent

   166

            item = PageInfo(None, url, title)

   168

            # are we the first item?

   169

            if not prev :

   170

                assert url == '', "Page list must begin with root item"

   171

   172

                # root node does not have a parent

   173

                parent = None

   174

   175

                # set root

   176

                self.root = item

   178

                # tee hee hee

   179

                self.root.add_child(self.root)

   181

                # initialize stack

   182

                stack.append((0, self.root))

   183

   184

            else :

   185

                # peek stack

   186

                stack_indent, stack_parent = stack[-1]

   187

   188

                # new indent level?

   189

                if indent > stack_indent :

   190

                    # set parent to previous item, and push new indent level + parent to stack

   191

                    parent = prev

   192

   193

                    # push new indent level + its parent

   194

                    stack.append((indent, parent))

   195

   196

                # same indent level as previous

   197

                elif indent == stack_indent :

   198

                    # parent is the one of the current stack level, stack doesn't change

   199

                    parent = stack_parent

   200

   201

                # unravel stack

   202

                elif indent < stack_indent :

   203

                    while True :

   204

                        # remove current stack level

   205

                        stack.pop(-1)

   206

   207

                        # peek next level

   208

                        stack_indent, stack_parent = stack[-1]

   209

   210

                        # found the level to return to?

   211

                        if stack_indent == indent :

   212

                            # restore prev

   213

                            parent = stack_parent

   214

   215

                            break

   216

   217

                        elif stack_indent < indent :

   218

                            assert False, "Bad un-indent"

   219

   220

            # add to parent?

   221

            if parent :

   222

                item.set_parent(parent)

   223

                parent.add_child(item)

   224

   225

            # update prev

   226

            prev = item

   228

        # get root

   229

        assert hasattr(self, 'root'), "No root item found!"

   230

   231

    def get_page (self, url) :

   232

        """

   233

            Lookup the given page URL, and return the matching PageInfo object, or None, if not found

   234

        """

   235

   236

        # start from root

   237

        node = self.root

   238

   239

        # traverse the object tree

   240

        for segment in url.split('/') :

   241

            if segment :

   242

                node = node.get_child(segment)

   243

   244

            if not node :

   245

                return None

   248

        return node

   249

   250

    def get_siblings (self, url) :

   251

        """

   252

            Get the list of siblings for the given url, including the given page itself

   253

        """

   254

   255

        # look up the page itself

   256

        page = self.get_page(url)

   257

   258

        # specialcase root/unknown node

   259

        if page and page.parent :

   260

            return page.parent.children

   262

        else :

   263

            return self.root.children

   264

   265

    def dump (self) :

   266

        """

   267

            Returns a string representation of the tree

   268

        """

   269

   270

        def _print_node (indent, node) :

   271

            return '\n'.join('%s%s' % (' '*indent, line) for line in [

   272

                "%-15s : %s" % (node.name, node.title)

   273

            ] + [

   274

                _print_node(indent + 4, child) for child in node.children

   275

            ])

   277

        return _print_node(0, self.root)

   278

   279

# global singleton PageList instance

   280

page_tree = PageTree()

   281

   282

def load_page_tree () :

   283

    """

   284

        Load the global singleton PageInfo instance

   285

    """

   286

   287

    page_tree._load()

   288

   289

# XXX: should inherit from PageInfo

   340

        page_info = page_tree.get_page(self.url)

   343

        if page_info :

   344

            title = page_info.title

   345

   346

        else :

   385

            page_tree   = page_tree