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

    """

    26

    27

    JS("""

    28

        var cache_file;

    29

    30

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

    31

        {

    32

            /*module_load_request[module_name] = 1;*/

    33

            return;

    34

        }

    35

    36

        if (path == null)

    37

        {

    38

            path = './';

    39

        }

    40

    41

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

    42

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

    43

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

    44

        {

    45

            cache_file =  sys.overrides.__getitem__(override_name) ;

    46

        }

    47

        else

    48

        {

    49

            cache_file =  module_name ;

    50

        }

    51

    52

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

    53

    54

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

    55

    56

        /* already loaded? */

    57

        if (module_load_request[module_name])

    58

        {

    59

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

    60

            {

    61

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

    62

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

    63

            }

    64

            return;

    65

        }

    66

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

    67

        {

    68

            module_load_request[module_name] = 1;

    69

        }

    70

    71

        /* following a load, this first executes the script

    72

         * "preparation" function MODULENAME_loaded_fn()

    73

         * and then sets up the loaded module in the namespace

    74

         * of the parent.

    75

         */

    76

    77

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

    78

    79

        if (parent_module != null)

    80

        {

    81

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

    82

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

    83

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

    84

        }

    85

    86

    87

        if (dynamic)

    88

        {

    89

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

    90

             */

    91

    92

            pyjs_load_script(cache_file, onload_fn, async);

    93

    94

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

    95

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

    96

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

    97

             */

    98

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

    99

        }

   100

        else

   101

        {

   102

            if (module_name != "pyjslib" &&

   103

                module_name != "sys")

   104

                pyjs_eval(onload_fn);

   105

        }

   106

   107

    """)

   108

   109

   110

JS("""

   111

function import_wait(proceed_fn, parent_mod, dynamic) {

   112

   113

    var data = '';

   114

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

   115

    $doc.body.appendChild(element);

   116

    function write_dom(txt) {

   117

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

   118

    }

   119

   120

    var timeoutperiod = 1;

   121

    if (dynamic)

   122

        var timeoutperiod = 1;

   123

   124

    var wait = function() {

   125

   126

        var status = '';

   127

        for (l in module_load_request)

   128

        {

   129

            var m = module_load_request[l];

   130

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

   131

                continue;

   132

            status += l + m + " ";

   133

        }

   134

   135

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

   136

        wait_count += 1;

   137

   138

        if (status == '')

   139

        {

   140

            setTimeout(wait, timeoutperiod);

   141

            return;

   142

        }

   143

   144

        for (l in module_load_request)

   145

        {

   146

            var m = module_load_request[l];

   147

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

   148

            {

   149

                module_load_request[l] = 4;

   150

                continue;

   151

            }

   152

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

   153

            {

   154

                if (m == 1)

   155

                {

   156

                    setTimeout(wait, timeoutperiod);

   157

                    return;

   158

                }

   159

                if (m == 2)

   160

                {

   161

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

   162

                    module_load_request[l] = 3;

   163

                }

   164

            }

   165

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

   166

            {

   167

                setTimeout(wait, timeoutperiod);

   168

                return;

   169

            }

   170

            if (m == 3)

   171

            {

   172

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

   173

                module_load_request[l] = 4;

   174

                mod_fn = modules[l];

   175

            }

   176

        }

   177

        //alert("module wait done");

   178

   179

        if (proceed_fn.importDone)

   180

            proceed_fn.importDone(proceed_fn);

   181

        else

   182

            proceed_fn();

   183

    }

   184

   185

    wait();

   186

}

   187

""")

   188

   189

   190

class Object:

   191

    pass

   192

   193

   194

object = Object

   195

   196

   197

class Modload:

   198

   199

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

   200

                 parent_mod):

   201

        self.app_modlist = app_modlist

   202

        self.app_imported_fn = app_imported_fn

   203

        self.path = path

   204

        self.idx = 0

   205

        self.dynamic = dynamic

   206

        self.parent_mod = parent_mod

   207

   208

    def next(self):

   209

   210

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

   211

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

   212

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

   213

        self.idx += 1

   214

   215

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

   216

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

   217

        else:

   218

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

   219

   220

   221

def get_module(module_name):

   224

    return __mod

   225

   226

   227

def preload_app_modules(path, app_modnames, app_imported_fn, dynamic,

   228

                        parent_mod=None):

   229

   230

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

   231

    loader.next()

   232

   233

   234

# as comment on line 20 says

   235

# import sys should be below

   236

import sys  # noqa # pylint: disable=C0411

   237

   238

   239

class BaseException:

   240

   241

    name = "BaseException"

   242

   243

    def __init__(self, *args):

   244

        self.args = args

   245

   246

    def __str__(self):

   247

        if len(self.args) is 0:

   248

            return ''

   249

        elif len(self.args) is 1:

   250

            return repr(self.args[0])

   251

        return repr(self.args)

   252

   253

    def toString(self):

   254

        return str(self)

   255

   256

   257

class Exception(BaseException):

   258

    name = "Exception"

   259

   260

   261

class TypeError(BaseException):

   262

    name = "TypeError"

   263

   264

   265

class StandardError(Exception):

   266

    name = "StandardError"

   267

   268

   269

class LookupError(StandardError):

   270

    name = "LookupError"

   271

   272

    def toString(self):

   273

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

   274

   275

   276

class KeyError(LookupError):

   277

    name = "KeyError"

   278

   279

   280

class AttributeError(StandardError):

   281

    name = "AttributeError"

   282

   283

    def toString(self):

   284

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

   285

   286

   287

JS("""

   288

pyjslib.StopIteration = function () { };

   289

pyjslib.StopIteration.prototype = new Error();

   290

pyjslib.StopIteration.name = 'StopIteration';

   291

pyjslib.StopIteration.message = 'StopIteration';

   292

   293

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

   294

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

   295

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

   296

   297

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

   298

    return pos;

   299

}

   300

   301

pyjslib.String_join = function(data) {

   302

    var text="";

   303

   304

    if (pyjslib.isArray(data)) {

   305

        return data.join(this);

   306

    }

   307

    else if (pyjslib.isIteratable(data)) {

   308

        var iter=data.__iter__();

   309

        try {

   310

            text+=iter.next();

   311

            while (true) {

   312

                var item=iter.next();

   313

                text+=this + item;

   314

            }

   315

        }

   316

        catch (e) {

   317

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

   318

        }

   319

    }

   320

   321

    return text;

   322

}

   323

   324

pyjslib.String_isdigit = function() {

   325

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

   326

}

   327

   328

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

   329

    var do_max=false;

   330

    var start=0;

   331

    var new_str="";

   332

    var pos=0;

   333

   334

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

   335

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

   336

   337

    while (start<this.length) {

   338

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

   339

   340

        pos=this.indexOf(old, start);

   341

        if (pos<0) break;

   342

   343

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

   344

        start=pos+old.length;

   345

    }

   346

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

   347

   348

    return new_str;

   349

}

   350

   351

pyjslib.String_split = function(sep, maxsplit) {

   352

    var items=new pyjslib.List();

   353

    var do_max=false;

   354

    var subject=this;

   355

    var start=0;

   356

    var pos=0;

   357

   358

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

   359

        sep=" ";

   360

        subject=subject.strip();

   361

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

   362

    }

   363

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

   364

   365

    if (subject.length == 0) {

   366

        return items;

   367

    }

   368

   369

    while (start<subject.length) {

   370

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

   371

   372

        pos=subject.indexOf(sep, start);

   373

        if (pos<0) break;

   374

   375

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

   376

        start=pos+sep.length;

   377

    }

   378

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

   379

   380

    return items;

   381

}

   382

   383

pyjslib.String___iter__ = function() {

   384

    var i = 0;

   385

    var s = this;

   386

    return {

   387

        'next': function() {

   388

            if (i >= s.length) {

   389

                throw pyjslib.StopIteration;

   390

            }

   391

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

   392

        },

   393

        '__iter__': function() {

   394

            return this;

   395

        }

   396

    };

   397

}

   398

   399

pyjslib.String_strip = function(chars) {

   400

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

   401

}

   402

   403

pyjslib.String_lstrip = function(chars) {

   404

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

   405

   406

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

   407

}

   408

   409

pyjslib.String_rstrip = function(chars) {

   410

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

   411

   412

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

   413

}

   414

   415

pyjslib.String_startswith = function(prefix, start) {

   416

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

   417

   418

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

   419

    return false;

   420

}

   421

   422

pyjslib.abs = Math.abs;

   423

   424

""")

   425

   426

   427

class Class:

   428

    def __init__(self, name):

   429

        self.name = name

   430

   431

    def __str___(self):

   432

        return self.name

   433

   434

   435

def eq(a, b):

   436

    JS("""

   437

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

   438

        return a.__cmp__(b) == 0;

   439

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

   440

        return b.__cmp__(a) == 0;

   441

    }

   442

    return a == b;

   443

    """)

   444

   445

   446

def cmp(a, b):

   447

    if hasattr(a, "__cmp__"):

   448

        return a.__cmp__(b)

   449

    elif hasattr(b, "__cmp__"):

   450

        return -b.__cmp__(a)

   451

    if a > b:

   452

        return 1

   453

    elif b > a:

   454

        return -1

   455

    else:

   456

        return 0

   457

   458

   459

def bool(v):

   460

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

   461

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

   462

    # recursion

   463

    JS("""

   464

    if (!v) return false;

   465

    switch(typeof v){

   466

    case 'boolean':

   467

        return v;

   468

    case 'object':

   469

        if (v.__nonzero__){

   470

            return v.__nonzero__();

   471

        }else if (v.__len__){

   472

            return v.__len__()>0;

   473

        }

   474

        return true;

   475

    }

   476

    return Boolean(v);

   477

    """)

   478

   479

   480

class List:

   481

    def __init__(self, data=None):

   482

        JS("""

   483

        this.l = [];

   484

        this.extend(data);

   485

        """)

   486

   487

    def append(self, item):

   488

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

   489

   490

    def extend(self, data):

   491

        JS("""

   492

        if (pyjslib.isArray(data)) {

   493

            n = this.l.length;

   494

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

   495

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

   496

                }

   497

            }

   498

        else if (pyjslib.isIteratable(data)) {

   499

            var iter=data.__iter__();

   500

            var i=this.l.length;

   501

            try {

   502

                while (true) {

   503

                    var item=iter.next();

   504

                    this.l[i++]=item;

   505

                    }

   506

                }

   507

            catch (e) {

   508

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

   509

                }

   510

            }

   511

        """)

   512

   513

    def remove(self, value):

   514

        JS("""

   515

        var index=this.index(value);

   516

        if (index<0) return false;

   517

        this.l.splice(index, 1);

   518

        return true;

   519

        """)

   520

   521

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

   522

        JS("""

   523

        var length=this.l.length;