1

#!/usr/bin/env python

     2

     3

import sys

     4

import os

     5

import shutil

     6

from copy import copy

     7

from os.path import join, dirname, basename, abspath, split, isfile, isdir

     8

from optparse import OptionParser

     9

import pyjs

    10

import time

    11

from cStringIO import StringIO

    12

try:

    13

    # Python 2.5 and above

    14

    from hashlib import md5

    15

except Exception:

    16

    import md5

    17

import re

    18

    19

usage = """

    20

  usage: %prog [options] <application module name or path>

    21

    22

This is the command line builder for the pyjamas project, which can

    23

be used to build Ajax applications from Python.

    24

For more information, see the website at http://pyjs.org/

    25

"""

    26

    27

# GWT1.2 Impl  | GWT1.2 Output         | Pyjamas 0.2 Platform | Pyjamas 0.2 Output

    28

# -------------+-----------------------+----------------------+----------------------

    29

# IE6          | ie6                   | IE6                  | ie6

    30

# Opera        | opera                 | Opera                | opera

    31

# Safari       | safari                | Safari               | safari

    32

# --           | gecko1_8              | Mozilla              | mozilla

    33

# --           | gecko                 | OldMoz               | oldmoz

    34

# Standard     | all                   | (default code)       | all

    35

# Mozilla      | gecko1_8, gecko       | --                   | --

    36

# Old          | safari, gecko, opera  | --                   | --

    37

    38

version = "%prog pyjamas version 2006-08-19"

    39

    40

# these names in lowercase need match the strings

    41

# returned by "provider$user.agent" in order to be selected corretly

    42

app_platforms = ['IE6', 'Opera', 'OldMoz', 'Safari', 'Mozilla']

    43

    44

# usually defaults to e.g. /usr/share/pyjamas

    45

_data_dir = os.path.join(pyjs.prefix, "share/pyjamas")

    46

    47

    48

# .cache.html files produces look like this

    49

CACHE_HTML_PAT = re.compile('^[a-z]*.[0-9a-f]{32}\.cache\.html$')

    50

    51

# ok these are the three "default" library directories, containing

    52

# the builtins (str, List, Dict, ord, round, len, range etc.)

    53

# the main pyjamas libraries (pyjamas.ui, pyjamas.Window etc.)

    54

# and the contributed addons

    55

    56

for p in ["library/builtins",

    57

          "library",

    58

          "addons"]:

    59

    p = os.path.join(_data_dir, p)

    60

    if os.path.isdir(p):

    61

        pyjs.path.append(p)

    62

    63

    64

def read_boilerplate(data_dir, filename):

    65

    return open(join(data_dir, "builder/boilerplate", filename)).read()

    66

    67

    68

def copy_boilerplate(data_dir, filename, output_dir):

    69

    filename = join(data_dir, "builder/boilerplate", filename)

    70

    shutil.copy(filename, output_dir)

    71

    72

    73

# taken and modified from python2.4

    74

def copytree_exists(src, dst, symlinks=False):

    75

    if not os.path.exists(src):

    76

        return

    77

    78

    names = os.listdir(src)

    79

    try:

    80

        os.mkdir(dst)

    81

    except Exception:

    82

        pass

    83

    84

    errors = []

    85

    for name in names:

    86

        if name.startswith('CVS'):

    87

            continue

    88

        if name.startswith('.git'):

    89

            continue

    90

        if name.startswith('.svn'):

    91

            continue

    92

    93

        srcname = os.path.join(src, name)

    94

        dstname = os.path.join(dst, name)

    95

        try:

    96

            if symlinks and os.path.islink(srcname):

    97

                linkto = os.readlink(srcname)

    98

                os.symlink(linkto, dstname)

    99

            elif isdir(srcname):

   100

                copytree_exists(srcname, dstname, symlinks)

   101

            else:

   102

                shutil.copy2(srcname, dstname)

   103

        except (IOError, os.error), why:

   104

            errors.append((srcname, dstname, why))

   105

    if errors:

   106

        print errors

   107

   108

   109

def check_html_file(source_file, dest_path):

   110

    """ Checks if a base HTML-file is available in the PyJamas

   111

        output directory.

   112

        If the HTML-file isn't available, it will be created.

   113

   114

        If a CSS-file with the same name is available

   115

        in the output directory, a reference to this CSS-file

   116

        is included.

   117

   118

        If no CSS-file is found, this function will look for a special

   119

        CSS-file in the output directory, with the name

   120

        "pyjamas_default.css", and if found it will be referenced

   121

        in the generated HTML-file.

   122

   123

        [thank you to stef mientki for contributing this function]

   124

    """

   125

   126

    base_html = """\

   127

<html>

   128

    <!-- auto-generated html - you should consider editing and

   129

         adapting this to suit your requirements

   130

     -->

   131

    <head>

   132

      <meta name="pygwt:module" content="%(modulename)s">

   133

      %(css)s

   134

      <title>%(title)s</title>

   135

    </head>

   136

    <body bgcolor="white">

   137

      <script language="javascript" src="pygwt.js"></script>

   138

    </body>

   139

</html>

   140

"""

   141

   142

    filename = os.path.split(source_file)[1]

   143

    mod_name = os.path.splitext(filename)[0]

   144

    file_name = os.path.join(dest_path, mod_name + '.html')

   145

   146

    # if html file in output directory exists, leave it alone.

   147

    if os.path.exists(file_name):

   148

        return 0

   149

   150

    if os.path.exists(os.path.join(dest_path, mod_name + '.css')):

   151

        css = "<link rel='stylesheet' href='" + mod_name + ".css'>"

   152

    elif os.path.exists(os.path.join(dest_path, 'pyjamas_default.css')):

   153

        css = "<link rel='stylesheet' href='pyjamas_default.css'>"

   154

   155

    else:

   156

        css = ''

   157

   158

    title = 'PyJamas Auto-Generated HTML file ' + mod_name

   159

   160

    base_html = base_html % {'modulename': mod_name, 'title': title, 'css': css}

   161

   162

    fh = open(file_name, 'w')

   163

    fh.write(base_html)

   164

    fh.close()

   165

   166

    return 1

   167

   168

   169

def build(app_name, output, js_includes=(), debug=False, dynamic=0,

   170

          data_dir=None, cache_buster=False, optimize=False):

   171

   172

    # make sure the output directory is always created in the current working

   173

    # directory or at the place given if it is an absolute path.

   174

    output = os.path.abspath(output)

   175

    msg = "Building '%(app_name)s' to output directory '%(output)s'" % locals()

   176

    if debug:

   177

        msg += " with debugging statements"

   178

    print msg

   179

   180

    # check the output directory

   181

    if os.path.exists(output) and not os.path.isdir(output):

   182

        print >>sys.stderr, "Output destination %s exists and is not a directory" % output

   183

        return

   184

    if not os.path.isdir(output):

   185

        try:

   186

            print "Creating output directory"

   187

            os.mkdir(output)

   188

        except StandardError, e:

   189

            print >>sys.stderr, "Exception creating output directory %s: %s" % (output, e)

   190

   191

    # public dir

   192

    for p in pyjs.path:

   193

        pub_dir = join(p, 'public')

   194

        if isdir(pub_dir):

   195

            print "Copying: public directory of library %r" % p

   196

            copytree_exists(pub_dir, output)

   197

   198

    # AppName.html - can be in current or public directory

   199

    html_input_filename = app_name + ".html"

   200

    html_output_filename = join(output, basename(html_input_filename))

   201

    if os.path.isfile(html_input_filename):

   202

        if not os.path.isfile(html_output_filename) or \

   203

               os.path.getmtime(html_input_filename) > \

   204

               os.path.getmtime(html_output_filename):

   205

            try:

   206

                shutil.copy(html_input_filename, html_output_filename)

   207

            except Exception:

   208

                print >>sys.stderr, "Warning: Missing module HTML file %s" % html_input_filename

   209

   210

            print "Copying: %(html_input_filename)s" % locals()

   211

   212

    if check_html_file(html_input_filename, output):

   213

        print >>sys.stderr, "Warning: Module HTML file %s has been auto-generated" % html_input_filename

   214

   215

    # pygwt.js

   216

   217

    print "Copying: pygwt.js"

   218

   219

    pygwt_js_template = read_boilerplate(data_dir, "pygwt.js")

   220

    pygwt_js_output = open(join(output, "pygwt.js"), "w")

   221

   222

    print >>pygwt_js_output, pygwt_js_template

   223

   224

    pygwt_js_output.close()

   225

   226

    # Images

   227

   228

    print "Copying: Images and History"

   229

    copy_boilerplate(data_dir, "corner_dialog_topleft_black.png", output)

   230

    copy_boilerplate(data_dir, "corner_dialog_topright_black.png", output)

   231

    copy_boilerplate(data_dir, "corner_dialog_bottomright_black.png", output)

   232

    copy_boilerplate(data_dir, "corner_dialog_bottomleft_black.png", output)

   233

    copy_boilerplate(data_dir, "corner_dialog_edge_black.png", output)

   234

    copy_boilerplate(data_dir, "corner_dialog_topleft.png", output)

   235

    copy_boilerplate(data_dir, "corner_dialog_topright.png", output)

   236

    copy_boilerplate(data_dir, "corner_dialog_bottomright.png", output)

   237

    copy_boilerplate(data_dir, "corner_dialog_bottomleft.png", output)

   238

    copy_boilerplate(data_dir, "corner_dialog_edge.png", output)

   239

    copy_boilerplate(data_dir, "tree_closed.gif", output)

   240

    copy_boilerplate(data_dir, "tree_open.gif", output)

   241

    copy_boilerplate(data_dir, "tree_white.gif", output)

   242

    copy_boilerplate(data_dir, "history.html", output)

   243

   244

    # all.cache.html

   245

    app_files = generateAppFiles(data_dir, js_includes, app_name, debug,

   246

                                 output, dynamic, cache_buster, optimize)

   247

   248

    # AppName.nocache.html

   249

   250

    print "Creating: %(app_name)s.nocache.html" % locals()

   251

   252

    home_nocache_html_template = read_boilerplate(data_dir, "home.nocache.html")

   253

    home_nocache_html_output = open(join(output, app_name + ".nocache.html"),

   254

                                    "w")

   255

   256

    # the selector templ is added to the selectScript function

   257

    select_tmpl = """O(["true","%s"],"%s");"""

   258

    script_selectors = StringIO()

   259

   260

    for platform, file_prefix in app_files:

   261

        print >> script_selectors, select_tmpl % (platform, file_prefix)

   262

   263

    print >>home_nocache_html_output, home_nocache_html_template % dict(

   264

        app_name=app_name,

   265

        script_selectors=script_selectors.getvalue(),

   266

    )

   267

   268

    home_nocache_html_output.close()

   269

   270

    print "Done. You can run your app by opening '%(html_output_filename)s' in a browser" % locals()

   271

   272

   273

def generateAppFiles(data_dir, js_includes, app_name, debug, output, dynamic,

   274

                     cache_buster, optimize):

   275

   276

    all_cache_html_template = read_boilerplate(data_dir, "all.cache.html")

   277

    mod_cache_html_template = read_boilerplate(data_dir, "mod.cache.html")

   278

   279

    # clean out the old ones first

   280

    for name in os.listdir(output):

   281

        if CACHE_HTML_PAT.match(name):

   282

            p = join(output, name)

   283

            print "Deleting existing app file %s" % p

   284

            os.unlink(p)

   285

   286

    app_files = []

   287

    tmpl = read_boilerplate(data_dir, "all.cache.html")

   288

    parser = pyjs.PlatformParser("platform")

   289

    app_headers = ''

   290

    scripts = ['<script type="text/javascript" src="%s"></script>' %

   291

               script for script in js_includes]

   292

    app_body = '\n'.join(scripts)

   293

   294

    mod_code = {}

   295

    mod_libs = {}

   296

    modules = {}

   297

    app_libs = {}

   298

    early_app_libs = {}

   299

    app_code = {}

   300

    overrides = {}

   301

    pover = {}

   302

    app_modnames = {}

   303

    mod_levels = {}

   304

   305

    # First, generate all the code.

   306

    # Second, (dynamic only), post-analyse the places where modules

   307

    # haven't changed

   308

    # Third, write everything out.

   309

   310

    for platform in app_platforms:

   311

   312

        mod_code[platform] = {}

   313

        mod_libs[platform] = {}

   314

        modules[platform] = []

   315

        pover[platform] = {}

   316

        app_libs[platform] = ''

   317

        early_app_libs[platform] = ''

   318

        app_code[platform] = {}

   319

        app_modnames[platform] = {}

   320

   321

        # Application.Platform.cache.html

   322

   323

        parser.setPlatform(platform)

   324

        app_translator = pyjs.AppTranslator(

   325

            parser=parser, dynamic=dynamic, optimize=optimize)

   326

        early_app_libs[platform], appcode = \

   327

            app_translator.translate(None, is_app=False,

   328

                                     debug=debug,

   329

                                     library_modules=['dynamicajax.js',

   330

                                                      '_pyjs.js', 'sys',

   331

                                                      'pyjslib'])

   332

        pover[platform].update(app_translator.overrides.items())

   333

        for mname, name in app_translator.overrides.items():

   334

            pd = overrides.setdefault(mname, {})

   335

            pd[platform] = name

   336

   337

        print appcode

   338

        # mod_code[platform][app_name] = appcode

   339

   340

        # platform.Module.cache.js

   341

   342

        modules_done = ['pyjslib', 'sys', '_pyjs.js']

   343

        # modules_to_do = [app_name] + app_translator.library_modules

   344

        modules_to_do = [app_name] + app_translator.library_modules

   345

   346

        dependencies = {}

   347

   348

        deps = map(pyjs.strip_py, modules_to_do)

   349

        for d in deps:

   350

            sublist = add_subdeps(dependencies, d)

   351

            modules_to_do += sublist

   352

        deps = uniquify(deps)

   353

        # dependencies[app_name] = deps

   354

   355

        modules[platform] = modules_done + modules_to_do

   356

   357

        while modules_to_do:

   358

   359

            # print "modules to do", modules_to_do

   360

   361

            mn = modules_to_do.pop()

   362

            mod_name = pyjs.strip_py(mn)

   363

   364

            if mod_name in modules_done:

   365

                continue

   366

   367

            modules_done.append(mod_name)

   368

   369

            mod_cache_name = "%s.%s.cache.js" % (platform.lower(), mod_name)

   370

   371

            parser.setPlatform(platform)

   372

            mod_translator = pyjs.AppTranslator(parser=parser, optimize=optimize)

   373

            mod_libs[platform][mod_name], mod_code[platform][mod_name] = \

   374

                mod_translator.translate(mod_name,

   375

                                         is_app=False,

   376

                                         debug=debug)

   377

            pover[platform].update(mod_translator.overrides.items())

   378

            for mname, name in mod_translator.overrides.items():

   379

                pd = overrides.setdefault(mname, {})

   380

                pd[platform] = name

   381

   382

            mods = mod_translator.library_modules

   383

            modules_to_do += mods

   384

            modules[platform] += mods

   385

   386

            deps = map(pyjs.strip_py, mods)

   387

            sd = subdeps(mod_name)

   388

            if len(sd) > 1:

   389

                deps += sd[:-1]

   390

            while mod_name in deps:

   391

                deps.remove(mod_name)

   392

   393

            # print

   394

            # print

   395

            # print "modname preadd:", mod_name, deps

   396

            # print

   397

            # print

   398

            for d in deps:

   399

                sublist = add_subdeps(dependencies, d)

   400

                modules_to_do += sublist

   401

            modules_to_do += add_subdeps(dependencies, mod_name)

   402

            # print "modname:", mod_name, deps

   403

            deps = uniquify(deps)

   404

            # print "modname:", mod_name, deps

   405

            dependencies[mod_name] = deps

   406

   407

        # work out the dependency ordering of the modules

   408

   409

        mod_levels[platform] = make_deps(None, dependencies, modules_done)

   410

   411

    # now write everything out

   412

   413

    for platform in app_platforms:

   414

   415

        early_app_libs_ = early_app_libs[platform]

   416

        app_libs_ = app_libs[platform]

   417

        app_code_ = app_code[platform]

   418

        # modules_ = filter_mods(app_name, modules[platform])

   419

        mods = flattenlist(mod_levels[platform])

   420

        mods.reverse()

   421

        modules_ = filter_mods(None, mods)

   422

   423

        for mod_name in modules_:

   424

   425

            mod_code_ = mod_code[platform][mod_name]

   426

   427

            mod_name = pyjs.strip_py(mod_name)

   428

   429

            override_name = "%s.%s" % (platform.lower(), mod_name)

   430

            if override_name in pover[platform]:

   431

                mod_cache_name = "%s.cache.js" % (override_name)

   432

            else:

   433

                mod_cache_name = "%s.cache.js" % (mod_name)

   434

   435

            print "Creating: " + mod_cache_name

   436

   437

            modlevels = make_deps(None, dependencies, dependencies[mod_name])

   438

   439

            modnames = []

   440

   441

            for md in modlevels:

   442

                mnames = map(lambda x: "'%s'" % x, md)

   443

                mnames = "new pyjslib.List([\n\t\t\t%s])" % ',\n\t\t\t'.join(mnames)

   444

                modnames.append(mnames)

   445

   446

            modnames.reverse()

   447

            modnames = "new pyjslib.List([\n\t\t%s\n\t])" % ',\n\t\t'.join(modnames)

   448

   449

            # convert the overrides

   450

   451

            overnames = map(lambda x: "'%s': '%s'" % x, pover[platform].items())

   452

            overnames = "new pyjslib.Dict({\n\t\t%s\n\t})" % ',\n\t\t'.join(overnames)

   453

   454

            if dynamic:

   455

                mod_cache_html_output = open(join(output, mod_cache_name), "w")

   456

            else:

   457

                mod_cache_html_output = StringIO()

   458

   459

            print >>mod_cache_html_output, mod_cache_html_template % dict(

   460

                mod_name=mod_name,

   461

                app_name=app_name,

   462

                modnames=modnames,

   463

                overrides=overnames,

   464

                mod_libs=mod_libs[platform][mod_name],

   465

                dynamic=dynamic,

   466

                mod_code=mod_code_,

   467

            )

   468

   469

            if dynamic:

   470

                mod_cache_html_output.close()

   471

            else:

   472

                mod_cache_html_output.seek(0)

   473

                app_libs_ += mod_cache_html_output.read()

   474

   475

        # write out the dependency ordering of the modules

   476

   477

        app_modnames = []

   478

   479

        for md in mod_levels[platform]:

   480

            mnames = map(lambda x: "'%s'" % x, md)

   481

            mnames = "new pyjslib.List([\n\t\t\t%s])" % ',\n\t\t\t'.join(mnames)

   482

            app_modnames.append(mnames)

   483

   484

        app_modnames.reverse()

   485

        app_modnames = "new pyjslib.List([\n\t\t%s\n\t])" % ',\n\t\t'.join(app_modnames)

   486

   487

        # convert the overrides

   488

   489

        overnames = map(lambda x: "'%s': '%s'" % x, pover[platform].items())

   490

        overnames = "new pyjslib.Dict({\n\t\t%s\n\t})" % ',\n\t\t'.join(overnames)

   491

   492

        # print "platform names", platform, overnames

   493

        # print pover

   494

   495

        # now write app.allcache including dependency-ordered list of

   496

        # library modules

   497

   498

        file_contents = all_cache_html_template % dict(

   499

            app_name=app_name,

   500

            early_app_libs=early_app_libs_,

   501

            app_libs=app_libs_,

   502

            app_code=app_code_,

   503

            app_body=app_body,

   504

            overrides=overnames,

   505

            platform=platform.lower(),

   506

            dynamic=dynamic,

   507

            app_modnames=app_modnames,

   508

            app_headers=app_headers

   509

        )

   510

        if cache_buster:

   511

            digest = md5.new(file_contents).hexdigest()

   512

            file_name = "%s.%s.%s" % (platform.lower(), app_name, digest)

   513

        else:

   514

            file_name = "%s.%s" % (platform.lower(), app_name)

   515

        file_name += ".cache.html"

   516

        out_path = join(output, file_name)

   517

        out_file = open(out_path, 'w')

   518

        out_file.write(file_contents)

   519

        out_file.close()