1

#!/usr/bin/env python

     2

     3

from __future__ import print_function

     4

import sys

     5

import shutil

     6

import time

     7

import re

     8

import os

     9

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

    10

from hashlib import md5

    11

from copy import copy

    12

from optparse import OptionParser

    13

from cStringIO import StringIO

    14

    15

import pyjs

    16

    17

    18

usage = """

    19

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

    20

    21

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

    22

be used to build Ajax applications from Python.

    23

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

    24

"""

    25

    26

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

    27

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

    28

# IE6          | ie6                   | IE6                  | ie6

    29

# Opera        | opera                 | Opera                | opera

    30

# Safari       | safari                | Safari               | safari

    31

# --           | gecko1_8              | Mozilla              | mozilla

    32

# --           | gecko                 | OldMoz               | oldmoz

    33

# Standard     | all                   | (default code)       | all

    34

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

    35

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

    36

    37

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

    38

    39

# these names in lowercase need match the strings

    40

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

    41

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

    42

    43

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

    44

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

    45

    46

    47

# .cache.html files produces look like this

    48

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

    49

    50

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

    51

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

    52

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

    53

# and the contributed addons

    54

    55

for p in ["library/builtins",

    56

          "library",

    57

          "addons"]:

    58

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

    59

    if os.path.isdir(p):

    60

        pyjs.path.append(p)

    61

    62

    63

def read_boilerplate(data_dir, filename):

    64

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

    65

    66

    67

def copy_boilerplate(data_dir, filename, output_dir):

    68

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

    69

    shutil.copy(filename, output_dir)

    70

    71

    72

# taken and modified from python2.4

    73

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

    74

    if not os.path.exists(src):

    75

        return

    76

    77

    names = os.listdir(src)

    78

    try:

    79

        os.mkdir(dst)

    80

    except Exception:

    81

        pass

    82

    83

    errors = []

    84

    for name in names:

    85

        if name.startswith('CVS'):

    86

            continue

    87

        if name.startswith('.git'):

    88

            continue

    89

        if name.startswith('.svn'):

    90

            continue

    91

    92

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

    93

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

    94

        try:

    95

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

    96

                linkto = os.readlink(srcname)

    97

                os.symlink(linkto, dstname)

    98

            elif isdir(srcname):

    99

                copytree_exists(srcname, dstname, symlinks)

   100

            else:

   101

                shutil.copy2(srcname, dstname)

   102

        except (IOError, os.error), why:

   103

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

   104

    if errors:

   105

        print(errors)

   106

   107

   108

def check_html_file(source_file, dest_path):

   109

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

   110

        output directory.

   111

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

   112

   113

        If a CSS-file with the same name is available

   114

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

   115

        is included.

   116

   117

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

   118

        CSS-file in the output directory, with the name

   119

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

   120

        in the generated HTML-file.

   121

   122

        [thank you to stef mientki for contributing this function]

   123

    """

   124

   125

    base_html = """\

   126

<html>

   127

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

   128

         adapting this to suit your requirements

   129

     -->

   130

    <head>

   131

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

   132

      %(css)s

   133

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

   134

    </head>

   135

    <body bgcolor="white">

   136

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

   137

    </body>

   138

</html>

   139

"""

   140

   141

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

   142

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

   143

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

   144

   145

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

   146

    if os.path.exists(file_name):

   147

        return 0

   148

   149

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

   150

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

   151

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

   152

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

   153

   154

    else:

   155

        css = ''

   156

   157

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

   158

   159

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

   160

   161

    fh = open(file_name, 'w')

   162

    fh.write(base_html)

   163

    fh.close()

   164

   165

    return 1

   166

   167

   168

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

   169

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

   170

   171

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

   172

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

   173

    output = os.path.abspath(output)

   174

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

   175

    if debug:

   176

        msg += " with debugging statements"

   177

    print(msg)

   178

   179

    # check the output directory

   180

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

   181

        print("Output destination %s exists and is not a directory" % output, file=sys.stderr)

   182

        return

   183

    if not os.path.isdir(output):

   184

        try:

   185

            print("Creating output directory")

   186

            os.mkdir(output)

   187

        except StandardError, e:

   188

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

   189

   190

    # public dir

   191

    for p in pyjs.path:

   192

        pub_dir = join(p, 'public')

   193

        if isdir(pub_dir):

   194

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

   195

            copytree_exists(pub_dir, output)

   196

   197

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

   198

    html_input_filename = app_name + ".html"

   199

    html_output_filename = join(output, basename(html_input_filename))

   200

    if os.path.isfile(html_input_filename):

   201

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

   202

               os.path.getmtime(html_input_filename) > \

   203

               os.path.getmtime(html_output_filename):

   204

            try:

   205

                shutil.copy(html_input_filename, html_output_filename)

   206

            except Exception:

   207

                print("Warning: Missing module HTML file %s" % html_input_filename, file=sys.stderr)

   208

   209

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

   210

   211

    if check_html_file(html_input_filename, output):

   212

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

   213

   214

    # pygwt.js

   215

   216

    print("Copying: pygwt.js")

   217

   218

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

   219

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

   220

   221

    print(pygwt_js_template, file=pygwt_js_output)

   222

   223

    pygwt_js_output.close()

   224

   225

    # Images

   226

   227

    print("Copying: Images and History")

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

   243

    # all.cache.html

   244

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

   245

                                 output, dynamic, cache_buster, optimize)

   246

   247

    # AppName.nocache.html

   248

   249

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

   250

   251

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

   252

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

   253

                                    "w")

   254

   255

    # the selector templ is added to the selectScript function

   256

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

   257

    script_selectors = StringIO()

   258

   259

    for platform, file_prefix in app_files:

   260

        print(select_tmpl % (platform, file_prefix), file=script_selectors)

   261

   262

    print(

   263

        home_nocache_html_template % dict(

   264

            app_name=app_name,

   265

            script_selectors=script_selectors.getvalue(),

   266

        ), file=home_nocache_html_output)

   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_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

            ), file=mod_cache_html_output)

   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)