1

#!/usr/bin/env python

     2

     3

from __future__ import print_function

     4

import sys

     5

import os

     6

import shutil

     7

from copy import copy

     8

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

     9

from optparse import OptionParser

    10

import pyjs

    11

import time

    12

from cStringIO import StringIO

    13

try:

    14

    # Python 2.5 and above

    15

    from hashlib import md5

    16

except Exception:

    17

    import md5

    18

import re

    19

    20

usage = """

    21

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

    22

    23

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

    24

be used to build Ajax applications from Python.

    25

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

    26

"""

    27

    28

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

    29

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

    30

# IE6          | ie6                   | IE6                  | ie6

    31

# Opera        | opera                 | Opera                | opera

    32

# Safari       | safari                | Safari               | safari

    33

# --           | gecko1_8              | Mozilla              | mozilla

    34

# --           | gecko                 | OldMoz               | oldmoz

    35

# Standard     | all                   | (default code)       | all

    36

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

    37

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

    38

    39

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

    40

    41

# these names in lowercase need match the strings

    42

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

    43

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

    44

    45

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

    46

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

    47

    48

    49

# .cache.html files produces look like this

    50

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

    51

    52

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

    53

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

    54

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

    55

# and the contributed addons

    56

    57

for p in ["library/builtins",

    58

          "library",

    59

          "addons"]:

    60

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

    61

    if os.path.isdir(p):

    62

        pyjs.path.append(p)

    63

    64

    65

def read_boilerplate(data_dir, filename):

    66

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

    67

    68

    69

def copy_boilerplate(data_dir, filename, output_dir):

    70

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

    71

    shutil.copy(filename, output_dir)

    72

    73

    74

# taken and modified from python2.4

    75

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

    76

    if not os.path.exists(src):

    77

        return

    78

    79

    names = os.listdir(src)

    80

    try:

    81

        os.mkdir(dst)

    82

    except Exception:

    83

        pass

    84

    85

    errors = []

    86

    for name in names:

    87

        if name.startswith('CVS'):

    88

            continue

    89

        if name.startswith('.git'):

    90

            continue

    91

        if name.startswith('.svn'):

    92

            continue

    93

    94

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

    95

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

    96

        try:

    97

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

    98

                linkto = os.readlink(srcname)

    99

                os.symlink(linkto, dstname)

   100

            elif isdir(srcname):

   101

                copytree_exists(srcname, dstname, symlinks)

   102

            else:

   103

                shutil.copy2(srcname, dstname)

   104

        except (IOError, os.error), why:

   105

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

   106

    if errors:

   107

        print(errors)

   108

   109

   110

def check_html_file(source_file, dest_path):

   111

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

   112

        output directory.

   113

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

   114

   115

        If a CSS-file with the same name is available

   116

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

   117

        is included.

   118

   119

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

   120

        CSS-file in the output directory, with the name

   121

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

   122

        in the generated HTML-file.

   123

   124

        [thank you to stef mientki for contributing this function]

   125

    """

   126

   127

    base_html = """\

   128

<html>

   129

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

   130

         adapting this to suit your requirements

   131

     -->

   132

    <head>

   133

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

   134

      %(css)s

   135

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

   136

    </head>

   137

    <body bgcolor="white">

   138

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

   139

    </body>

   140

</html>

   141

"""

   142

   143

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

   144

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

   145

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

   146

   147

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

   148

    if os.path.exists(file_name):

   149

        return 0

   150

   151

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

   152

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

   153

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

   154

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

   155

   156

    else:

   157

        css = ''

   158

   159

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

   160

   161

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

   162

   163

    fh = open(file_name, 'w')

   164

    fh.write(base_html)

   165

    fh.close()

   166

   167

    return 1

   168

   169

   170

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

   171

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

   172

   173

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

   174

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

   175

    output = os.path.abspath(output)

   176

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

   177

    if debug:

   178

        msg += " with debugging statements"

   179

    print(msg)

   180

   181

    # check the output directory

   182

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

   183

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

   184

        return

   185

    if not os.path.isdir(output):

   186

        try:

   187

            print("Creating output directory")

   188

            os.mkdir(output)

   189

        except StandardError, e:

   190

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

   191

   192

    # public dir

   193

    for p in pyjs.path:

   194

        pub_dir = join(p, 'public')

   195

        if isdir(pub_dir):

   196

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

   197

            copytree_exists(pub_dir, output)

   198

   199

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

   200

    html_input_filename = app_name + ".html"

   201

    html_output_filename = join(output, basename(html_input_filename))

   202

    if os.path.isfile(html_input_filename):

   203

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

   204

               os.path.getmtime(html_input_filename) > \

   205

               os.path.getmtime(html_output_filename):

   206

            try:

   207

                shutil.copy(html_input_filename, html_output_filename)

   208

            except Exception:

   209

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

   210

   211

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

   212

   213

    if check_html_file(html_input_filename, output):

   214

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

   215

   216

    # pygwt.js

   217

   218

    print("Copying: pygwt.js")

   219

   220

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

   221

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

   222

   223

    print(pygwt_js_template, file=pygwt_js_output)

   224

   225

    pygwt_js_output.close()

   226

   227

    # Images

   228

   229

    print("Copying: Images and History")

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

   245

    # all.cache.html

   246

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

   247

                                 output, dynamic, cache_buster, optimize)

   248

   249

    # AppName.nocache.html

   250

   251

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

   252

   253

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

   254

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

   255

                                    "w")

   256

   257

    # the selector templ is added to the selectScript function

   258

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

   259

    script_selectors = StringIO()

   260

   261

    for platform, file_prefix in app_files:

   262

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

   263

   264

    print(

   265

        home_nocache_html_template % dict(

   266

            app_name=app_name,

   267

            script_selectors=script_selectors.getvalue(),

   268

        ), file=home_nocache_html_output)

   269

   270

    home_nocache_html_output.close()

   271

   272

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

   273

   274

   275

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

   276

                     cache_buster, optimize):

   277

   278

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

   279

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

   280

   281

    # clean out the old ones first

   282

    for name in os.listdir(output):

   283

        if CACHE_HTML_PAT.match(name):

   284

            p = join(output, name)

   285

            print("Deleting existing app file %s" % p)

   286

            os.unlink(p)

   287

   288

    app_files = []

   289

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

   290

    parser = pyjs.PlatformParser("platform")

   291

    app_headers = ''

   292

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

   293

               script for script in js_includes]

   294

    app_body = '\n'.join(scripts)

   295

   296

    mod_code = {}

   297

    mod_libs = {}

   298

    modules = {}

   299

    app_libs = {}

   300

    early_app_libs = {}

   301

    app_code = {}

   302

    overrides = {}

   303

    pover = {}

   304

    app_modnames = {}

   305

    mod_levels = {}

   306

   307

    # First, generate all the code.

   308

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

   309

    # haven't changed

   310

    # Third, write everything out.

   311

   312

    for platform in app_platforms:

   313

   314

        mod_code[platform] = {}

   315

        mod_libs[platform] = {}

   316

        modules[platform] = []

   317

        pover[platform] = {}

   318

        app_libs[platform] = ''

   319

        early_app_libs[platform] = ''

   320

        app_code[platform] = {}

   321

        app_modnames[platform] = {}

   322

   323

        # Application.Platform.cache.html

   324

   325

        parser.setPlatform(platform)

   326

        app_translator = pyjs.AppTranslator(

   327

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

   328

        early_app_libs[platform], appcode = \

   329

            app_translator.translate(None, is_app=False,

   330

                                     debug=debug,

   331

                                     library_modules=['dynamicajax.js',

   332

                                                      '_pyjs.js', 'sys',

   333

                                                      'pyjslib'])

   334

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

   335

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

   336

            pd = overrides.setdefault(mname, {})

   337

            pd[platform] = name

   338

   339

        print(appcode)

   340

        # mod_code[platform][app_name] = appcode

   341

   342

        # platform.Module.cache.js

   343

   344

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

   345

        # modules_to_do = [app_name] + app_translator.library_modules

   346

        modules_to_do = [app_name] + app_translator.library_modules

   347

   348

        dependencies = {}

   349

   350

        deps = map(pyjs.strip_py, modules_to_do)

   351

        for d in deps:

   352

            sublist = add_subdeps(dependencies, d)

   353

            modules_to_do += sublist

   354

        deps = uniquify(deps)

   355

        # dependencies[app_name] = deps

   356

   357

        modules[platform] = modules_done + modules_to_do

   358

   359

        while modules_to_do:

   360

   361

            # print "modules to do", modules_to_do

   362

   363

            mn = modules_to_do.pop()

   364

            mod_name = pyjs.strip_py(mn)

   365

   366

            if mod_name in modules_done:

   367

                continue

   368

   369

            modules_done.append(mod_name)

   370

   371

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

   372

   373

            parser.setPlatform(platform)

   374

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

   375

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

   376

                mod_translator.translate(mod_name,

   377

                                         is_app=False,

   378

                                         debug=debug)

   379

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

   380

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

   381

                pd = overrides.setdefault(mname, {})

   382

                pd[platform] = name

   383

   384

            mods = mod_translator.library_modules

   385

            modules_to_do += mods

   386

            modules[platform] += mods

   387

   388

            deps = map(pyjs.strip_py, mods)

   389

            sd = subdeps(mod_name)

   390

            if len(sd) > 1:

   391

                deps += sd[:-1]

   392

            while mod_name in deps:

   393

                deps.remove(mod_name)

   394

   395

            # print

   396

            # print

   397

            # print "modname preadd:", mod_name, deps

   398

            # print

   399

            # print

   400

            for d in deps:

   401

                sublist = add_subdeps(dependencies, d)

   402

                modules_to_do += sublist

   403

            modules_to_do += add_subdeps(dependencies, mod_name)

   404

            # print "modname:", mod_name, deps

   405

            deps = uniquify(deps)

   406

            # print "modname:", mod_name, deps

   407

            dependencies[mod_name] = deps

   408

   409

        # work out the dependency ordering of the modules

   410

   411

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

   412

   413

    # now write everything out

   414

   415

    for platform in app_platforms:

   416

   417

        early_app_libs_ = early_app_libs[platform]

   418

        app_libs_ = app_libs[platform]

   419

        app_code_ = app_code[platform]

   420

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

   421

        mods = flattenlist(mod_levels[platform])

   422

        mods.reverse()

   423

        modules_ = filter_mods(None, mods)

   424

   425

        for mod_name in modules_:

   426

   427

            mod_code_ = mod_code[platform][mod_name]

   428

   429

            mod_name = pyjs.strip_py(mod_name)

   430

   431

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

   432

            if override_name in pover[platform]:

   433

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

   434

            else:

   435

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

   436

   437

            print("Creating: " + mod_cache_name)

   438

   439

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

   440

   441

            modnames = []

   442

   443

            for md in modlevels:

   444

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

   445

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

   446

                modnames.append(mnames)

   447

   448

            modnames.reverse()

   449

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

   450

   451

            # convert the overrides

   452

   453

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

   454

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

   455

   456

            if dynamic:

   457

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

   458

            else:

   459

                mod_cache_html_output = StringIO()

   460

   461

            print(mod_cache_html_template % dict(

   462

                mod_name=mod_name,

   463

                app_name=app_name,

   464

                modnames=modnames,

   465

                overrides=overnames,

   466

                mod_libs=mod_libs[platform][mod_name],

   467

                dynamic=dynamic,

   468

                mod_code=mod_code_,

   469

            ), file=mod_cache_html_output)

   470

   471

            if dynamic:

   472

                mod_cache_html_output.close()

   473

            else:

   474

                mod_cache_html_output.seek(0)

   475

                app_libs_ += mod_cache_html_output.read()

   476

   477

        # write out the dependency ordering of the modules

   478

   479

        app_modnames = []

   480

   481

        for md in mod_levels[platform]:

   482

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

   483

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

   484

            app_modnames.append(mnames)

   485

   486

        app_modnames.reverse()

   487

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

   488

   489

        # convert the overrides

   490

   491

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

   492

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

   493

   494

        # print "platform names", platform, overnames

   495

        # print pover

   496

   497

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

   498

        # library modules

   499

   500

        file_contents = all_cache_html_template % dict(

   501

            app_name=app_name,

   502

            early_app_libs=early_app_libs_,

   503

            app_libs=app_libs_,

   504

            app_code=app_code_,

   505

            app_body=app_body,

   506

            overrides=overnames,

   507

            platform=platform.lower(),

   508

            dynamic=dynamic,

   509

            app_modnames=app_modnames,

   510

            app_headers=app_headers

   511

        )

   512

        if cache_buster:

   513

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

   514

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

   515

        else: