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

    15

    16

# iteration from Bob Ippolito's Iteration in JavaScript

    17

    18

from __pyjamas__ import JS

    19

    20

# must declare import _before_ importing sys

    21

    22

    23

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

    24

    25

    JS("""

    26

        var cache_file;

    27

    28

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

    29

        {

    30

            /*module_load_request[module_name] = 1;*/

    31

            return;

    32

        }

    33

    34

        if (path == null)

    35

        {

    36

            path = './';

    37

        }

    38

    39

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

    40

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

    41

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

    42

        {

    43

            cache_file =  sys.overrides.__getitem__(override_name) ;

    44

        }

    45

        else

    46

        {

    47

            cache_file =  module_name ;

    48

        }

    49

    50

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

    51

    52

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

    53

    54

        /* already loaded? */

    55

        if (module_load_request[module_name])

    56

        {

    57

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

    58

            {

    59

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

    60

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

    61

            }

    62

            return;

    63

        }

    64

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

    65

        {

    66

            module_load_request[module_name] = 1;

    67

        }

    68

    69

        /* following a load, this first executes the script

    70

         * "preparation" function MODULENAME_loaded_fn()

    71

         * and then sets up the loaded module in the namespace

    72

         * of the parent.

    73

         */

    74

    75

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

    76

    77

        if (parent_module != null)

    78

        {

    79

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

    80

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

    81

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

    82

        }

    83

    84

    85

        if (dynamic)

    86

        {

    87

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

    88

             */

    89

    90

            pyjs_load_script(cache_file, onload_fn, async);

    91

    92

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

    93

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

    94

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

    95

             */

    96

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

    97

        }

    98

        else

    99

        {

   100

            if (module_name != "pyjslib" &&

   101

                module_name != "sys")

   102

                pyjs_eval(onload_fn);

   103

        }

   104

   105

    """)

   106

   107

   108

JS("""

   109

function import_wait(proceed_fn, parent_mod, dynamic) {

   110

   111

    var data = '';

   112

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

   113

    $doc.body.appendChild(element);

   114

    function write_dom(txt) {

   115

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

   116

    }

   117

   118

    var timeoutperiod = 1;

   119

    if (dynamic)

   120

        var timeoutperiod = 1;

   121

   122

    var wait = function() {

   123

   124

        var status = '';

   125

        for (l in module_load_request)

   126

        {

   127

            var m = module_load_request[l];

   128

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

   129

                continue;

   130

            status += l + m + " ";

   131

        }

   132

   133

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

   134

        wait_count += 1;

   135

   136

        if (status == '')

   137

        {

   138

            setTimeout(wait, timeoutperiod);

   139

            return;

   140

        }

   141

   142

        for (l in module_load_request)

   143

        {

   144

            var m = module_load_request[l];

   145

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

   146

            {

   147

                module_load_request[l] = 4;

   148

                continue;

   149

            }

   150

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

   151

            {

   152

                if (m == 1)

   153

                {

   154

                    setTimeout(wait, timeoutperiod);

   155

                    return;

   156

                }

   157

                if (m == 2)

   158

                {

   159

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

   160

                    module_load_request[l] = 3;

   161

                }

   162

            }

   163

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

   164

            {

   165

                setTimeout(wait, timeoutperiod);

   166

                return;

   167

            }

   168

            if (m == 3)

   169

            {

   170

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

   171

                module_load_request[l] = 4;

   172

                mod_fn = modules[l];

   173

            }

   174

        }

   175

        //alert("module wait done");

   176

   177

        if (proceed_fn.importDone)

   178

            proceed_fn.importDone(proceed_fn);

   179

        else

   180

            proceed_fn();

   181

    }

   182

   183

    wait();

   184

}

   185

""")

   186

   187

   188

# pylint: disable=C1001

   189

class Object:

   190

    pass

   191

   192

   193

object = Object

   194

   195

   196

class Modload:

   197

   198

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

   199

                 parent_mod):

   200

        self.app_modlist = app_modlist

   201

        self.app_imported_fn = app_imported_fn

   202

        self.path = path

   203

        self.idx = 0

   204

        self.dynamic = dynamic

   205

        self.parent_mod = parent_mod

   206

   207

    def next(self):

   208

   209

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

   210

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

   211

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

   212

        self.idx += 1

   213

   214

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

   215

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

   216

        else:

   217

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

   218

   219

   220

def get_module(module_name):

   221

    _ev = "__mod = %s;" % module_name

   222

    JS("pyjs_eval(_ev);")

   223

    return __mod

   224

   225

   226

def preload_app_modules(path, app_modnames, app_imported_fn, dynamic,

   227

                        parent_mod=None):

   228

   229

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

   230

    loader.next()

   231

   232

   233

# as comment on line 20 says

   234

# import sys should be below

   235

import sys  # noqa # pylint: disable=C0411,W0611

   236

   237

   238

class BaseException:

   239

   240

    name = "BaseException"

   241

   242

    def __init__(self, *args):

   243

        self.args = args

   244

   245

    def __str__(self):

   246

        if len(self.args) is 0:

   247

            return ''

   248

        elif len(self.args) is 1:

   249

            return repr(self.args[0])

   250

        return repr(self.args)

   251

   252

    def toString(self):

   253

        return str(self)

   254

   255

   256

class Exception(BaseException):

   257

    name = "Exception"

   258

   259

   260

class TypeError(BaseException):

   261

    name = "TypeError"

   262

   263

   264

class StandardError(Exception):

   265

    name = "StandardError"

   266

   267

   268

class LookupError(StandardError):

   269

    name = "LookupError"

   270

   271

    def toString(self):

   272

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

   273

   274

   275

class KeyError(LookupError):

   276

    name = "KeyError"

   277

   278

   279

class AttributeError(StandardError):

   280

    name = "AttributeError"

   281

   282

    def toString(self):

   283

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

   284

   285

   286

JS("""

   287

pyjslib.StopIteration = function () { };

   288

pyjslib.StopIteration.prototype = new Error();

   289

pyjslib.StopIteration.name = 'StopIteration';

   290

pyjslib.StopIteration.message = 'StopIteration';

   291

   292

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

   293

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

   294

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

   295

   296

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

   297

    return pos;

   298

}

   299

   300

pyjslib.String_join = function(data) {

   301

    var text="";

   302

   303

    if (pyjslib.isArray(data)) {

   304

        return data.join(this);

   305

    }

   306

    else if (pyjslib.isIteratable(data)) {

   307

        var iter=data.__iter__();

   308

        try {

   309

            text+=iter.next();

   310

            while (true) {

   311

                var item=iter.next();

   312

                text+=this + item;

   313

            }

   314

        }

   315

        catch (e) {

   316

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

   317

        }

   318

    }

   319

   320

    return text;

   321

}

   322

   323

pyjslib.String_isdigit = function() {

   324

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

   325

}

   326

   327

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

   328

    var do_max=false;

   329

    var start=0;

   330

    var new_str="";

   331

    var pos=0;

   332

   333

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

   334

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

   335

   336

    while (start<this.length) {

   337

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

   338

   339

        pos=this.indexOf(old, start);

   340

        if (pos<0) break;

   341

   342

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

   343

        start=pos+old.length;

   344

    }

   345

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

   346

   347

    return new_str;

   348

}

   349

   350

pyjslib.String_split = function(sep, maxsplit) {

   351

    var items=new pyjslib.List();

   352

    var do_max=false;

   353

    var subject=this;

   354

    var start=0;

   355

    var pos=0;

   356

   357

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

   358

        sep=" ";

   359

        subject=subject.strip();

   360

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

   361

    }

   362

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

   363

   364

    if (subject.length == 0) {

   365

        return items;

   366

    }

   367

   368

    while (start<subject.length) {

   369

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

   370

   371

        pos=subject.indexOf(sep, start);

   372

        if (pos<0) break;

   373

   374

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

   375

        start=pos+sep.length;

   376

    }

   377

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

   378

   379

    return items;

   380

}

   381

   382

pyjslib.String___iter__ = function() {

   383

    var i = 0;

   384

    var s = this;

   385

    return {

   386

        'next': function() {

   387

            if (i >= s.length) {

   388

                throw pyjslib.StopIteration;

   389

            }

   390

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

   391

        },

   392

        '__iter__': function() {

   393

            return this;

   394

        }

   395

    };

   396

}

   397

   398

pyjslib.String_strip = function(chars) {

   399

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

   400

}

   401

   402

pyjslib.String_lstrip = function(chars) {

   403

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

   404

   405

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

   406

}

   407

   408

pyjslib.String_rstrip = function(chars) {

   409

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

   410

   411

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

   412

}

   413

   414

pyjslib.String_startswith = function(prefix, start) {

   415

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

   416

   417

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

   418

    return false;

   419

}

   420

   421

pyjslib.abs = Math.abs;

   422

   423

""")

   424

   425

   426

class Class:

   427

    def __init__(self, name):

   428

        self.name = name

   429

   430

    def __str___(self):

   431

        return self.name

   432

   433

   434

def eq(a, b):

   435

    JS("""

   436

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

   437

        return a.__cmp__(b) == 0;

   438

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

   439

        return b.__cmp__(a) == 0;

   440

    }

   441

    return a == b;

   442

    """)

   443

   444

   445

def cmp(a, b):

   446

    if hasattr(a, "__cmp__"):

   447

        return a.__cmp__(b)

   448

    elif hasattr(b, "__cmp__"):

   449

        return -b.__cmp__(a)

   450

    if a > b:

   451

        return 1

   452

    elif b > a:

   453

        return -1

   454

    else:

   455

        return 0

   456

   457

   458

def bool(v):

   459

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

   460

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

   461

    # recursion

   462

    JS("""

   463

    if (!v) return false;

   464

    switch(typeof v){

   465

    case 'boolean':

   466

        return v;

   467

    case 'object':

   468

        if (v.__nonzero__){

   469

            return v.__nonzero__();

   470

        }else if (v.__len__){

   471

            return v.__len__()>0;

   472

        }

   473

        return true;

   474

    }

   475

    return Boolean(v);

   476

    """)

   477

   478

   479

class List:

   480

    def __init__(self, data=None):

   481

        JS("""

   482

        this.l = [];

   483

        this.extend(data);

   484

        """)

   485

   486

    def append(self, item):

   487

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

   488

   489

    def extend(self, data):

   490

        JS("""

   491

        if (pyjslib.isArray(data)) {

   492

            n = this.l.length;

   493

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

   494

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

   495

                }

   496

            }

   497

        else if (pyjslib.isIteratable(data)) {

   498

            var iter=data.__iter__();

   499

            var i=this.l.length;

   500

            try {

   501

                while (true) {

   502

                    var item=iter.next();

   503

                    this.l[i++]=item;

   504

                    }

   505

                }

   506

            catch (e) {

   507

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

   508

                }

   509

            }

   510

        """)

   511

   512

    def remove(self, value):

   513

        JS("""

   514

        var index=this.index(value);

   515

        if (index<0) return false;

   516

        this.l.splice(index, 1);

   517

        return true;

   518

        """)

   519

   520

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

   521

        JS("""

   522

        var length=this.l.length;

   523

        for (var i=start; i<length; i++) {