1

# Copyright 2006 James Tauber and contributors

     2

#

     3

# Licensed under the Apache License, Version 2.0 (the "License");

     4

# you may not use this file except in compliance with the License.

     5

# You may obtain a copy of the License at

     6

#

     7

#     http://www.apache.org/licenses/LICENSE-2.0

     8

#

     9

# Unless required by applicable law or agreed to in writing, software

    10

# distributed under the License is distributed on an "AS IS" BASIS,

    11

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    12

# See the License for the specific language governing permissions and

    13

# limitations under the License.

    14

    16

    17

# iteration from Bob Ippolito's Iteration in JavaScript

    18

    19

from __pyjamas__ import JS

    20

    21

# must declare import _before_ importing sys

    22

    23

    24

def import_module(path, parent_module, module_name, dynamic=1, async=False):

    25

    26

    JS("""

    27

        var cache_file;

    28

    29

        if (module_name == "sys" || module_name == 'pyjslib')

    30

        {

    31

            /*module_load_request[module_name] = 1;*/

    32

            return;

    33

        }

    34

    35

        if (path == null)

    36

        {

    37

            path = './';

    38

        }

    39

    40

        var override_name = sys.platform + "." + module_name;

    41

        if (((sys.overrides != null) &&

    42

             (sys.overrides.has_key(override_name))))

    43

        {

    44

            cache_file =  sys.overrides.__getitem__(override_name) ;

    45

        }

    46

        else

    47

        {

    48

            cache_file =  module_name ;

    49

        }

    50

    51

        cache_file = (path + cache_file + '.cache.js' ) ;

    52

    53

        //alert("cache " + cache_file + " " + module_name + " " + parent_module);

    54

    55

        /* already loaded? */

    56

        if (module_load_request[module_name])

    57

        {

    58

            if (module_load_request[module_name] >= 3 && parent_module != null)

    59

            {

    60

                //onload_fn = parent_module + '.' + module_name + ' = ' + module_name + ';';

    61

                //pyjs_eval(onload_fn); /* set up the parent-module namespace */

    62

            }

    63

            return;

    64

        }

    65

        if (typeof (module_load_request[module_name]) == 'undefined')

    66

        {

    67

            module_load_request[module_name] = 1;

    68

        }

    69

    70

        /* following a load, this first executes the script

    71

         * "preparation" function MODULENAME_loaded_fn()

    72

         * and then sets up the loaded module in the namespace

    73

         * of the parent.

    74

         */

    75

    76

        onload_fn = ''; // module_name + "_loaded_fn();"

    77

    78

        if (parent_module != null)

    79

        {

    80

            //onload_fn += parent_module + '.' + module_name + ' = ' + module_name + ';';

    81

            /*pmod = parent_module + '.' + module_name;

    82

            onload_fn += 'alert("' + pmod + '"+' + pmod+');';*/

    83

        }

    84

    85

    86

        if (dynamic)

    87

        {

    88

            /* this one tacks the script onto the end of the DOM

    89

             */

    90

    91

            pyjs_load_script(cache_file, onload_fn, async);

    92

    93

            /* this one actually RUNS the script (eval) into the page.

    94

               my feeling is that this would be better for non-async

    95

               but i can't get it to work entirely yet.

    96

             */

    97

            /*pyjs_ajax_eval(cache_file, onload_fn, async);*/

    98

        }

    99

        else

   100

        {

   101

            if (module_name != "pyjslib" &&

   102

                module_name != "sys")

   103

                pyjs_eval(onload_fn);

   104

        }

   105

   106

    """)

   107

   108

   109

JS("""

   110

function import_wait(proceed_fn, parent_mod, dynamic) {

   111

   112

    var data = '';

   113

    var element = $doc.createElement("div");

   114

    $doc.body.appendChild(element);

   115

    function write_dom(txt) {

   116

        element.innerHTML = txt + '<br />';

   117

    }

   118

   119

    var timeoutperiod = 1;

   120

    if (dynamic)

   121

        var timeoutperiod = 1;

   122

   123

    var wait = function() {

   124

   125

        var status = '';

   126

        for (l in module_load_request)

   127

        {

   128

            var m = module_load_request[l];

   129

            if (l == "sys" || l == 'pyjslib')

   130

                continue;

   131

            status += l + m + " ";

   132

        }

   133

   134

        //write_dom( " import wait " + wait_count + " " + status + " parent_mod " + parent_mod);

   135

        wait_count += 1;

   136

   137

        if (status == '')

   138

        {

   139

            setTimeout(wait, timeoutperiod);

   140

            return;

   141

        }

   142

   143

        for (l in module_load_request)

   144

        {

   145

            var m = module_load_request[l];

   146

            if (l == "sys" || l == 'pyjslib')

   147

            {

   148

                module_load_request[l] = 4;

   149

                continue;

   150

            }

   151

            if ((parent_mod != null) && (l == parent_mod))

   152

            {

   153

                if (m == 1)

   154

                {

   155

                    setTimeout(wait, timeoutperiod);

   156

                    return;

   157

                }

   158

                if (m == 2)

   159

                {

   160

                    /* cheat and move app on to next stage */

   161

                    module_load_request[l] = 3;

   162

                }

   163

            }

   164

            if (m == 1 || m == 2)

   165

            {

   166

                setTimeout(wait, timeoutperiod);

   167

                return;

   168

            }

   169

            if (m == 3)

   170

            {

   171

                //alert("waited for module " + l + ": loaded");

   172

                module_load_request[l] = 4;

   173

                mod_fn = modules[l];

   174

            }

   175

        }

   176

        //alert("module wait done");

   177

   178

        if (proceed_fn.importDone)

   179

            proceed_fn.importDone(proceed_fn);

   180

        else

   181

            proceed_fn();

   182

    }

   183

   184

    wait();

   185

}

   186

""")

   187

   188

   189

# pylint: disable=old-style-class

   190

class Object:

   191

    def __init__(self):

   192

        pass

   193

   194

   195

object = Object

   196

   197

   198

class Modload:

   199

   200

    def __init__(self, path, app_modlist, app_imported_fn, dynamic,

   201

                 parent_mod):

   202

        self.app_modlist = app_modlist

   203

        self.app_imported_fn = app_imported_fn

   204

        self.path = path

   205

        self.idx = 0

   206

        self.dynamic = dynamic

   207

        self.parent_mod = parent_mod

   208

   209

    def next(self):

   210

   211

        for i in range(len(self.app_modlist[self.idx])):

   212

            app = self.app_modlist[self.idx][i]

   213

            import_module(self.path, self.parent_mod, app, self.dynamic, True)

   214

        self.idx += 1

   215

   216

        if self.idx >= len(self.app_modlist):

   217

            import_wait(self.app_imported_fn, self.parent_mod, self.dynamic)

   218

        else:

   219

            import_wait(getattr(self, "next"), self.parent_mod, self.dynamic)

   220

   221

   222

def get_module(module_name):

   223

    _ev = "__mod = %s;" % module_name

   224

    JS("pyjs_eval(_ev);")

   225

    return __mod

   226

   227

   228

def preload_app_modules(path, app_modnames, app_imported_fn, dynamic,

   229

                        parent_mod=None):

   230

   231

    loader = Modload(path, app_modnames, app_imported_fn, dynamic, parent_mod)

   232

    loader.next()

   233

   234

   235

# as comment on line 20 says

   236

# import sys should be below

   237

import sys  # noqa # pylint: disable=wrong-import-order,unused-import,wrong-import-position

   238

   239

   240

class BaseException:

   241

   242

    name = "BaseException"

   243

   244

    def __init__(self, *args):

   245

        self.args = args

   246

   247

    def __str__(self):

   248

        if len(self.args) is 0:

   249

            return ''

   250

        elif len(self.args) is 1:

   251

            return repr(self.args[0])

   252

        return repr(self.args)

   253

   254

    def toString(self):

   255

        return str(self)

   256

   257

   258

class Exception(BaseException):

   259

    name = "Exception"

   260

   261

   262

class TypeError(BaseException):

   263

    name = "TypeError"

   264

   265

   266

class StandardError(Exception):

   267

    name = "StandardError"

   268

   269

   270

class LookupError(StandardError):

   271

    name = "LookupError"

   272

   273

    def toString(self):

   274

        return self.name + ": " + self.args[0]

   275

   276

   277

class KeyError(LookupError):

   278

    name = "KeyError"

   279

   280

   281

class AttributeError(StandardError):

   282

    name = "AttributeError"

   283

   284

    def toString(self):

   285

        return "AttributeError: %s of %s" % (self.args[1], self.args[0])

   286

   287

   288

JS("""

   289

pyjslib.StopIteration = function () { };

   290

pyjslib.StopIteration.prototype = new Error();

   291

pyjslib.StopIteration.name = 'StopIteration';

   292

pyjslib.StopIteration.message = 'StopIteration';

   293

   294

pyjslib.String_find = function(sub, start, end) {

   295

    var pos=this.indexOf(sub, start);

   296

    if (pyjslib.isUndefined(end)) return pos;

   297

   298

    if (pos + sub.length>end) return -1;

   299

    return pos;

   300

}

   301

   302

pyjslib.String_join = function(data) {

   303

    var text="";

   304

   305

    if (pyjslib.isArray(data)) {

   306

        return data.join(this);

   307

    }

   308

    else if (pyjslib.isIteratable(data)) {

   309

        var iter=data.__iter__();

   310

        try {

   311

            text+=iter.next();

   312

            while (true) {

   313

                var item=iter.next();

   314

                text+=this + item;

   315

            }

   316

        }

   317

        catch (e) {

   318

            if (e != pyjslib.StopIteration) throw e;

   319

        }

   320

    }

   321

   322

    return text;

   323

}

   324

   325

pyjslib.String_isdigit = function() {

   326

    return (this.match(/^\d+$/g) != null);

   327

}

   328

   329

pyjslib.String_replace = function(old, replace, count) {

   330

    var do_max=false;

   331

    var start=0;

   332

    var new_str="";

   333

    var pos=0;

   334

   335

    if (!pyjslib.isString(old)) return this.__replace(old, replace);

   336

    if (!pyjslib.isUndefined(count)) do_max=true;

   337

   338

    while (start<this.length) {

   339

        if (do_max && !count--) break;

   340

   341

        pos=this.indexOf(old, start);

   342

        if (pos<0) break;

   343

   344

        new_str+=this.substring(start, pos) + replace;

   345

        start=pos+old.length;

   346

    }

   347

    if (start<this.length) new_str+=this.substring(start);

   348

   349

    return new_str;

   350

}

   351

   352

pyjslib.String_split = function(sep, maxsplit) {

   353

    var items=new pyjslib.List();

   354

    var do_max=false;

   355

    var subject=this;

   356

    var start=0;

   357

    var pos=0;

   358

   359

    if (pyjslib.isUndefined(sep) || pyjslib.isNull(sep)) {

   360

        sep=" ";

   361

        subject=subject.strip();

   362

        subject=subject.replace(/\s+/g, sep);

   363

    }

   364

    else if (!pyjslib.isUndefined(maxsplit)) do_max=true;

   365

   366

    if (subject.length == 0) {

   367

        return items;

   368

    }

   369

   370

    while (start<subject.length) {

   371

        if (do_max && !maxsplit--) break;

   372

   373

        pos=subject.indexOf(sep, start);

   374

        if (pos<0) break;

   375

   376

        items.append(subject.substring(start, pos));

   377

        start=pos+sep.length;

   378

    }

   379

    if (start<=subject.length) items.append(subject.substring(start));

   380

   381

    return items;

   382

}

   383

   384

pyjslib.String___iter__ = function() {

   385

    var i = 0;

   386

    var s = this;

   387

    return {

   388

        'next': function() {

   389

            if (i >= s.length) {

   390

                throw pyjslib.StopIteration;

   391

            }

   392

            return s.substring(i++, i, 1);

   393

        },

   394

        '__iter__': function() {

   395

            return this;

   396

        }

   397

    };

   398

}

   399

   400

pyjslib.String_strip = function(chars) {

   401

    return this.lstrip(chars).rstrip(chars);

   402

}

   403

   404

pyjslib.String_lstrip = function(chars) {

   405

    if (pyjslib.isUndefined(chars)) return this.replace(/^\s+/, "");

   406

   407

    return this.replace(new RegExp("^[" + chars + "]+"), "");

   408

}

   409

   410

pyjslib.String_rstrip = function(chars) {

   411

    if (pyjslib.isUndefined(chars)) return this.replace(/\s+$/, "");

   412

   413

    return this.replace(new RegExp("[" + chars + "]+$"), "");

   414

}

   415

   416

pyjslib.String_startswith = function(prefix, start) {

   417

    if (pyjslib.isUndefined(start)) start = 0;

   418

   419

    if (this.substring(start, prefix.length) == prefix) return true;

   420

    return false;

   421

}

   422

   423

pyjslib.abs = Math.abs;

   424

   425

""")

   426

   427

   428

class Class:

   429

    def __init__(self, name):

   430

        self.name = name

   431

   432

    def __str___(self):

   433

        return self.name

   434

   435

   436

def eq(a, b):

   437

    JS("""

   438

    if (pyjslib.hasattr(a, "__cmp__")) {

   439

        return a.__cmp__(b) == 0;

   440

    } else if (pyjslib.hasattr(b, "__cmp__")) {

   441

        return b.__cmp__(a) == 0;

   442

    }

   443

    return a == b;

   444

    """)

   445

   446

   447

def cmp(a, b):

   448

    if hasattr(a, "__cmp__"):

   449

        return a.__cmp__(b)

   450

    elif hasattr(b, "__cmp__"):

   451

        return -b.__cmp__(a)

   452

    if a > b:

   453

        return 1

   454

    elif b > a:

   455

        return -1

   456

    else:

   457

        return 0

   458

   459

   460

def bool(v):

   461

    # this needs to stay in native code without any dependencies here,

   462

    # because this is used by if and while, we need to prevent

   463

    # recursion

   464

    JS("""

   465

    if (!v) return false;

   466

    switch(typeof v){

   467

    case 'boolean':

   468

        return v;

   469

    case 'object':

   470

        if (v.__nonzero__){

   471

            return v.__nonzero__();

   472

        }else if (v.__len__){

   473

            return v.__len__()>0;

   474

        }

   475

        return true;

   476

    }

   477

    return Boolean(v);

   478

    """)

   479

   480

   481

class List:

   482

    def __init__(self, data=None):

   483

        JS("""

   484

        this.l = [];

   485

        this.extend(data);

   486

        """)

   487

   488

    def append(self, item):

   489

        JS("""    this.l[this.l.length] = item;""")

   490

   491

    def extend(self, data):

   492

        JS("""

   493

        if (pyjslib.isArray(data)) {

   494

            n = this.l.length;

   495

            for (var i=0; i < data.length; i++) {

   496

                this.l[n+i]=data[i];

   497

                }

   498

            }

   499

        else if (pyjslib.isIteratable(data)) {

   500

            var iter=data.__iter__();

   501

            var i=this.l.length;

   502

            try {

   503

                while (true) {

   504

                    var item=iter.next();

   505

                    this.l[i++]=item;

   506

                    }

   507

                }

   508

            catch (e) {

   509

                if (e != pyjslib.StopIteration) throw e;

   510

                }

   511

            }

   512

        """)

   513

   514

    def remove(self, value):

   515

        JS("""

   516

        var index=this.index(value);

   517

        if (index<0) return false;

   518

        this.l.splice(index, 1);

   519

        return true;

   520

        """)

   521

   522

    def index(self, value, start=0):

   523

        JS("""