1

import os, os.path

     2

     3

import settings, image, utils, helpers, log

     4

from template import gallery as gallery_tpl

     5

from helpers import url_for_page

     6

     7

def dirUp (count=1) :

     8

    """

     9

        Returns a relative path to the directly count levels above the current one

    10

    """

    11

    12

    if not count :

    13

        return '.'

    14

    15

    return os.path.join(*(['..']*count))

    16

    17

class Folder (object) :

    18

    def __init__ (self, name='.', parent=None) :

    19

        # the directory name, no trailing /

    20

        self.name = unicode(name.rstrip(os.sep))

    21

    22

        # our parent Folder, or None

    23

        self.parent = parent

    24

    25

        # the path to this dir, as a relative path to the root of the image gallery, always starts with .

    26

        if parent and name :

    27

            self.path = parent.pathFor(self.name)

    28

        else :

    29

            self.path = self.name

    30

    31

        # the url-path to the index.html file

    32

        self.html_path = self.path

    33

    34

        # dict of fname -> Folder

    35

        self.subdirs = {}

    36

    37

        # dict of fname -> Image

    38

        self.images = {}

    39

    40

        # our human-friendly title

    41

        self.title = None

    42

    43

        # our long-winded description

    44

        self.descr = ''

    45

    46

        # is this folder non-empty?

    47

        self.alive = None

    48

    49

        # self.images.values(), but sorted by filename

    50

        self.sorted_images = []

    51

    52

        # the ShortURL key to this dir

    53

        self.shorturl_code = None

    54

    55

        # were we filtered out?

    56

        self.filtered = False

    57

    58

    def pathFor (self, *fnames) :

    59

        """

    60

            Return a root-relative path to the given path inside this dir

    61

        """

    62

        return os.path.join(self.path, *fnames)

    63

    64

    def index (self, filters=None) :

    65

        """

    66

            Look for other dirs and images inside this dir. Filters must be either None,

    67

            whereupon all files will be included, or a dict of {filename -> next_filter}.

    68

            If given, only filenames that are present in the dict will be indexed, and in

    69

            the case of dirs, the next_filter will be passed on to that Folder's index

    70

            method.

    71

        """

    72

    73

        if filters :

    74

            self.filtered = True

    75

    76

        # iterate through listdir

    77

        for fname in os.listdir(self.path) :

    78

            # the full filesystem path to it

    79

            fpath = self.pathFor(fname)

    80

    81

            # ignore dotfiles

    82

            if fname.startswith('.') :

    83

                log.debug("Skipping dotfile %s", fname)

    84

                continue

    85

    86

            # apply filters

    87

            if filters :

    88

                if fname in filters :

    89

                    next_filter = filters[fname]

    90

                else :

    91

                    log.debug("Skip `%s' as we have a filter", fname)

    92

                    continue

    93

            else :

    94

                next_filter = None

    95

    96

            # recurse into subdirs, but not thumbs/previews

    97

            if (os.path.isdir(fpath) 

    98

                and (fname not in (settings.THUMB_DIR, settings.PREVIEW_DIR))

    99

                and (self.parent or fname not in settings.ROOT_IGNORE)

   100

            ) :

   101

                log.down(fname)

   102

   103

                f = Folder(fname, self)

   104

   105

                try :

   106

                    if f.index(next_filter) :   # recursion

   107

                        # if a subdir is alive, we are alive as well

   108

                        self.subdirs[fname] = f

   109

                        self.alive = True

   110

                except Exception, e :

   111

                    log.warning("skip - %s: %s" % (type(e), e))

   112

   113

                log.up()

   114

   115

            # handle images

   116

            elif os.path.isfile(fpath) and utils.isImage(fname) :

   117

                log.next(fname)

   118

                self.images[fname] = image.Image(self, fname)

   119

   120

            # ignore everything else

   121

            else :

   122

                log.debug("Ignoring file %s", fname)

   123

   124

        # sort and link the images

   125

        if self.images :

   126

            self.alive = True

   127

   128

            # sort the images

   129

            fnames = self.images.keys()

   130

            fnames.sort()

   131

   132

            prev = None

   133

   134

            # link

   135

            for fname in fnames :

   136

                img = self.images[fname]

   137

   138

                img.prev = prev

   139

   140

                if prev :

   141

                    prev.next = img

   142

   143

                prev = img

   144

   145

                # add to the sorted images list

   146

                self.sorted_images.append(img)

   147

   148

        # figure out our title/ descr. Must be done before our parent dir is rendered (self.title)

   149

        title_path = self.pathFor(settings.TITLE_FILE)

   150

   151

        self.title, self.descr = utils.readTitleDescr(title_path)

   152

   153

        # default title for the root dir

   154

        if self.title or self.descr :

   155

            self.alive = True

   156

            pass # use what was in the title file

   157

   158

        elif not self.parent :

   159

            self.title = 'Index'

   160

   161

        else :

   162

            self.title = self.name

   163

   164

        if not self.alive :

   165

            log.debug("Dir %s isn't alive" % self.path)

   166

   167

        return self.alive

   168

   169

    def getObjInfo (self) :

   170

        """

   171

            Metadata for shorturls2.db

   172

        """

   173

        return 'dir', self.path, ''

   174

   175

    def breadcrumb (self, forImg=None) :

   176

        """

   177

            Returns a [(fname, title)] list of this dir's parent dirs

   178

        """

   179

   180

        f = self

   181

        b = []

   182

        d = 0

   183

   184

        while f :

   185

            # functionality of the slightly-hacked-in variety

   186

            if f is self and forImg is not None :

   187

                url = helpers.url_for_page(self.getPageNumber(forImg))

   188

            else :

   189

                url = dirUp(d)

   190

   191

            b.insert(0, (url, f.title))

   192

   193

            d += 1

   194

            f = f.parent

   195

   196

        return b

   197

   198

    def getPageNumber (self, img) :

   199

        """

   200

            Get the page number that the given image is on

   201

        """

   202

   203

        return self.sorted_images.index(img) // settings.IMAGE_COUNT

   204

   205

    def countParents (self, acc=0) :

   206

        if self.parent :

   207

            return self.parent.countParents(acc+1)

   208

        else :

   209

            return acc

   210

   211

    def inRoot (self, *fnames) :

   212

        """

   213

            Return a relative URL from this dir to the given path in the root dir

   214

        """

   215

   216

        c = self.countParents()

   217

   218

        return utils.url_join(*((['..']*c) + list(fnames)))

   219

   220

    def render (self) :

   221

        """

   222

            Render the index.html, Images, and recurse into subdirs

   223

        """

   224

   225

        # ded folders are skipped

   226

        if not self.alive :

   227

            # dead, skip, no output

   228

            return

   229

   230

        index_mtime = utils.mtime(self.pathFor("index.html"))

   231

        dir_mtime = utils.mtime(self.path)

   232

   233

        # if this dir's contents were filtered out, then we can't render the index.html, as we aren't aware of all the images in here

   234

        if self.filtered :

   235

            log.warning("Dir `%s' contents were filtered, so we won't render the gallery index again", self.path)

   236

   237

        elif index_mtime > dir_mtime :

   238

            # no changes, pass, ignored

   239

            pass

   240

   241

        else :  

   242

            # create the thumb/preview dirs if needed

   243

            for dir in (settings.THUMB_DIR, settings.PREVIEW_DIR) :

   244

                path = self.pathFor(dir)

   245

   246

                if not os.path.isdir(path) :

   247

                    log.info("mkdir %s", dir)

   248

                    os.mkdir(path)

   249

   250

            # sort the subdirs

   251

            subdirs = self.subdirs.values()

   252

            subdirs.sort(key=lambda d: d.name)

   253

   254

            # paginate!

   255

            images = self.sorted_images

   256

            image_count = len(images)

   257

            pages = []

   258

   259

            while images :

   260

                pages.append(images[:settings.IMAGE_COUNT])

   261

                images = images[settings.IMAGE_COUNT:]

   262

   263

            pagination_required = len(pages) > 1

   264

   265

            if pagination_required :

   266

                log.info("%d pages @ %d images", len(pages), settings.IMAGE_COUNT)

   267

            elif not pages :

   268

                log.info("no images, render for subdirs")

   269

                pages = [[]]

   270

   271

            for cur_page, images in enumerate(pages) :

   272

                if pagination_required and cur_page > 0 :

   273

                    shorturl = "%s/%s" % (self.shorturl_code, cur_page+1)

   274

                else :

   275

                    shorturl = self.shorturl_code

   276

   277

                # render to index.html

   278

                gallery_tpl.render_to(self.pathFor(url_for_page(cur_page)), 

   279

                    stylesheet_url               = self.inRoot('style.css'),

   280

                    title                        = self.title,

   281

                    breadcrumb                   = self.breadcrumb(),

   282

   283

                    dirs                         = subdirs,

   284

                    images                       = images,

   285

   286

                    num_pages                    = len(pages),

   287

                    cur_page                     = cur_page,

   288

   289

                    description                  = self.descr,

   290

   291

                    shorturl                     = self.inRoot('s', shorturl),

   292

                    shorturl_code                = shorturl,

   293

                )

   294

   295

        # render images

   296

        image_count = len(self.sorted_images)

   297

        for i, img in enumerate(self.images.itervalues()) :

   298

            log.next("[%-4d/%4d] %s", i + 1, image_count, img.name)

   299

   300

            img.render()

   301

   302

        # recurse into subdirs

   303

        for dir in self.subdirs.itervalues() :

   304

            log.down(dir.name)

   305

   306

            dir.render()

   307

   308

            log.up()

   309