1

#!/usr/bin/env python

     2

     3

from __future__ import print_function

     4

import sys

     5

import shutil

     6

import re

     7

import os

     9

from hashlib import md5

    10

from optparse import OptionParser

    11

from cStringIO import StringIO

    12

    13

import pyjs

    14

    15

    16

usage = """

    17

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

    18

    19

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

    20

be used to build Ajax applications from Python.

    21

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

    22

"""

    23

    24

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

    25

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

    26

# IE6          | ie6                   | IE6                  | ie6

    27

# Opera        | opera                 | Opera                | opera

    28

# Safari       | safari                | Safari               | safari

    29

# --           | gecko1_8              | Mozilla              | mozilla

    30

# --           | gecko                 | OldMoz               | oldmoz

    31

# Standard     | all                   | (default code)       | all

    32

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

    33

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

    34

    35

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

    36

    37

# these names in lowercase need match the strings

    38

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

    39

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

    40

    41

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

    42

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

    43

    44

    45

# .cache.html files produces look like this

    46

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

    47

    48

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

    49

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

    50

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

    51

# and the contributed addons

    52

    53

for p in ["library/builtins",

    54

          "library",

    55

          "addons"]:

    56

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

    57

    if os.path.isdir(p):

    58

        pyjs.path.append(p)

    59

    60

    61

def read_boilerplate(data_dir, filename):

    62

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

    63

    64

    65

def copy_boilerplate(data_dir, filename, output_dir):

    66

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

    67

    shutil.copy(filename, output_dir)

    68

    69

    70

# taken and modified from python2.4

    71

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

    72

    if not os.path.exists(src):

    73

        return

    74

    75

    names = os.listdir(src)

    76

    try:

    77

        os.mkdir(dst)

    78

    except Exception:

    79

        pass

    80

    81

    errors = []

    82

    for name in names:

    83

        if name.startswith('CVS'):

    84

            continue

    85

        if name.startswith('.git'):

    86

            continue

    87

        if name.startswith('.svn'):

    88

            continue

    89

    90

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

    91

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

    92

        try:

    93

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

    94

                linkto = os.readlink(srcname)

    95

                os.symlink(linkto, dstname)

    96

            elif isdir(srcname):

    97

                copytree_exists(srcname, dstname, symlinks)

    98

            else:

    99

                shutil.copy2(srcname, dstname)

   100

        except (IOError, os.error), why:

   101

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

   102

    if errors:

   103

        print(errors)

   104

   105

   106

def check_html_file(source_file, dest_path):

   107

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

   108

        output directory.

   109

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

   110

   111

        If a CSS-file with the same name is available

   112

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

   113

        is included.

   114

   115

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

   116

        CSS-file in the output directory, with the name

   117

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

   118

        in the generated HTML-file.

   119

   120

        [thank you to stef mientki for contributing this function]

   121

    """

   122

   123

    base_html = """\

   124

<html>

   125

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

   126

         adapting this to suit your requirements

   127

     -->

   128

    <head>

   129

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

   130

      %(css)s

   131

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

   132

    </head>

   133

    <body bgcolor="white">

   134

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

   135

    </body>

   136

</html>

   137

"""

   138

   139

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

   140

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

   141

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

   142

   143

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

   144

    if os.path.exists(file_name):

   145

        return 0

   146

   147

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

   148

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

   149

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

   150

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

   151

   152

    else:

   153

        css = ''

   154

   155

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

   156

   157

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

   158

   159

    fh = open(file_name, 'w')

   160

    fh.write(base_html)

   161

    fh.close()

   162

   163

    return 1

   164

   165

   166

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

   167

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

   168

   169

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

   170

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

   171

    output = os.path.abspath(output)

   172

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

   173

    if debug:

   174

        msg += " with debugging statements"

   175

    print(msg)

   176

   177

    # check the output directory

   178

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

   179

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

   180

        return

   181

    if not os.path.isdir(output):

   182

        try:

   183

            print("Creating output directory")

   184

            os.mkdir(output)

   185

        except StandardError, e:

   186

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

   187

   188

    # public dir

   189

    for p in pyjs.path:

   190

        pub_dir = join(p, 'public')

   191

        if isdir(pub_dir):

   192

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

   193

            copytree_exists(pub_dir, output)

   194

   195

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

   196

    html_input_filename = app_name + ".html"

   197

    html_output_filename = join(output, basename(html_input_filename))

   198

    if os.path.isfile(html_input_filename):

   199

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

   200

               os.path.getmtime(html_input_filename) > \

   201

               os.path.getmtime(html_output_filename):

   202

            try:

   203

                shutil.copy(html_input_filename, html_output_filename)

   204

            except Exception:

   205

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

   206

   207

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

   208

   209

    if check_html_file(html_input_filename, output):

   210

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

   211

   212

    # pygwt.js

   213

   214

    print("Copying: pygwt.js")

   215

   216

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

   217

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

   218

   219

    print(pygwt_js_template, file=pygwt_js_output)

   220

   221

    pygwt_js_output.close()

   222

   223

    # Images

   224

   225

    print("Copying: Images and History")

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

   241

    # all.cache.html

   242

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

   243

                                 output, dynamic, cache_buster, optimize)

   244

   245

    # AppName.nocache.html

   246

   247

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

   248

   249

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

   250

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

   251

                                    "w")

   252

   253

    # the selector templ is added to the selectScript function

   254

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

   255

    script_selectors = StringIO()

   256

   257

    for platform, file_prefix in app_files:

   258

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

   259

   260

    print(

   261

        home_nocache_html_template % dict(

   262

            app_name=app_name,

   263

            script_selectors=script_selectors.getvalue(),

   264

        ), file=home_nocache_html_output)

   265

   266

    home_nocache_html_output.close()

   267

   268

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

   269

   270

   271

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

   272

                     cache_buster, optimize):

   273

   274

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

   275

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

   276

   277

    # clean out the old ones first

   278

    for name in os.listdir(output):

   279

        if CACHE_HTML_PAT.match(name):

   280

            p = join(output, name)

   281

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

   282

            os.unlink(p)

   283

   284

    app_files = []

   285

    parser = pyjs.PlatformParser("platform")

   286

    app_headers = ''

   287

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

   288

               script for script in js_includes]

   289

    app_body = '\n'.join(scripts)

   290

   291

    mod_code = {}

   292

    mod_libs = {}

   293

    modules = {}

   294

    app_libs = {}

   295

    early_app_libs = {}

   296

    app_code = {}

   297

    overrides = {}

   298

    pover = {}

   299

    app_modnames = {}

   300

    mod_levels = {}

   301

   302

    # First, generate all the code.

   303

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

   304

    # haven't changed

   305

    # Third, write everything out.

   306

   307

    for platform in app_platforms:

   308

   309

        mod_code[platform] = {}

   310

        mod_libs[platform] = {}

   311

        modules[platform] = []

   312

        pover[platform] = {}

   313

        app_libs[platform] = ''

   314

        early_app_libs[platform] = ''

   315

        app_code[platform] = {}

   316

        app_modnames[platform] = {}

   317

   318

        # Application.Platform.cache.html

   319

   320

        parser.setPlatform(platform)

   321

        app_translator = pyjs.AppTranslator(

   322

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

   323

        early_app_libs[platform], appcode = \

   324

            app_translator.translate(None, is_app=False,

   325

                                     debug=debug,

   326

                                     library_modules=['dynamicajax.js',

   327

                                                      '_pyjs.js', 'sys',

   328

                                                      'pyjslib'])

   329

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

   330

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

   331

            pd = overrides.setdefault(mname, {})

   332

            pd[platform] = name

   333

   334

        print(appcode)

   335

        # mod_code[platform][app_name] = appcode

   336

   337

        # platform.Module.cache.js

   338

   339

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

   340

        # modules_to_do = [app_name] + app_translator.library_modules

   341

        modules_to_do = [app_name] + app_translator.library_modules

   342

   343

        dependencies = {}

   344

   345

        deps = map(pyjs.strip_py, modules_to_do)

   346

        for d in deps:

   347

            sublist = add_subdeps(dependencies, d)

   348

            modules_to_do += sublist

   349

        deps = uniquify(deps)

   350

        # dependencies[app_name] = deps

   351

   352

        modules[platform] = modules_done + modules_to_do

   353

   354

        while modules_to_do:

   355

   356

            # print "modules to do", modules_to_do

   357

   358

            mn = modules_to_do.pop()

   359

            mod_name = pyjs.strip_py(mn)

   360

   361

            if mod_name in modules_done:

   362

                continue

   363

   364

            modules_done.append(mod_name)

   365

   366

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

   367

   368

            parser.setPlatform(platform)

   369

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

   370

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

   371

                mod_translator.translate(mod_name,

   372

                                         is_app=False,

   373

                                         debug=debug)

   374

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

   375

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

   376

                pd = overrides.setdefault(mname, {})

   377

                pd[platform] = name

   378

   379

            mods = mod_translator.library_modules

   380

            modules_to_do += mods

   381

            modules[platform] += mods

   382

   383

            deps = map(pyjs.strip_py, mods)

   384

            sd = subdeps(mod_name)

   385

            if len(sd) > 1:

   386

                deps += sd[:-1]

   387

            while mod_name in deps:

   388

                deps.remove(mod_name)

   389

   390

            # print

   391

            # print

   392

            # print "modname preadd:", mod_name, deps

   393

            # print

   394

            # print

   395

            for d in deps:

   396

                sublist = add_subdeps(dependencies, d)

   397

                modules_to_do += sublist

   398

            modules_to_do += add_subdeps(dependencies, mod_name)

   399

            # print "modname:", mod_name, deps

   400

            deps = uniquify(deps)

   401

            # print "modname:", mod_name, deps

   402

            dependencies[mod_name] = deps

   403

   404

        # work out the dependency ordering of the modules

   405

   406

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

   407

   408

    # now write everything out

   409

   410

    for platform in app_platforms:

   411

   412

        early_app_libs_ = early_app_libs[platform]

   413

        app_libs_ = app_libs[platform]

   414

        app_code_ = app_code[platform]

   415

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

   416

        mods = flattenlist(mod_levels[platform])

   417

        mods.reverse()

   418

        modules_ = filter_mods(None, mods)

   419

   420

        for mod_name in modules_:

   421

   422

            mod_code_ = mod_code[platform][mod_name]

   423

   424

            mod_name = pyjs.strip_py(mod_name)

   425

   426

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

   427

            if override_name in pover[platform]:

   428

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

   429

            else:

   430

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

   431

   432

            print("Creating: " + mod_cache_name)

   433

   434

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

   435

   436

            modnames = []

   437

   438

            for md in modlevels:

   439

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

   440

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

   441

                modnames.append(mnames)

   442

   443

            modnames.reverse()

   444

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

   445

   446

            # convert the overrides

   447

   448

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

   449

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

   450

   451

            if dynamic:

   452

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

   453

            else:

   454

                mod_cache_html_output = StringIO()

   455

   456

            print(mod_cache_html_template % dict(

   457

                mod_name=mod_name,

   458

                app_name=app_name,

   459

                modnames=modnames,

   460

                overrides=overnames,

   461

                mod_libs=mod_libs[platform][mod_name],

   462

                dynamic=dynamic,

   463

                mod_code=mod_code_,

   464

            ), file=mod_cache_html_output)

   465

   466

            if dynamic:

   467

                mod_cache_html_output.close()

   468

            else:

   469

                mod_cache_html_output.seek(0)

   470

                app_libs_ += mod_cache_html_output.read()

   471

   472

        # write out the dependency ordering of the modules

   473

   474

        app_modnames = []

   475

   476

        for md in mod_levels[platform]:

   477

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

   478

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

   479

            app_modnames.append(mnames)

   480

   481

        app_modnames.reverse()

   482

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

   483

   484

        # convert the overrides

   485

   486

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

   487

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

   488

   489

        # print "platform names", platform, overnames

   490

        # print pover

   491

   492

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

   493

        # library modules

   494

   495

        file_contents = all_cache_html_template % dict(

   496

            app_name=app_name,

   497

            early_app_libs=early_app_libs_,

   498

            app_libs=app_libs_,

   499

            app_code=app_code_,

   500

            app_body=app_body,

   501

            overrides=overnames,

   502

            platform=platform.lower(),

   503

            dynamic=dynamic,

   504

            app_modnames=app_modnames,

   505

            app_headers=app_headers

   506

        )

   507

        if cache_buster:

   508

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

   509

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

   510

        else:

   511

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

   512

        file_name += ".cache.html"

   513

        out_path = join(output, file_name)

   514

        out_file = open(out_path, 'w')

   515