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):

   222

    ev = "__mod = %s;" % module_name

   223

    JS("pyjs_eval(ev);")

   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

import sys

   235

   236

   237

class BaseException:

   238

   239

    name = "BaseException"

   240

   241

    def __init__(self, *args):

   242

        self.args = args

   243

   244

    def __str__(self):

   245

        if len(self.args) is 0:

   246

            return ''

   247

        elif len(self.args) is 1:

   248

            return repr(self.args[0])

   249

        return repr(self.args)

   250

   251

    def toString(self):

   252

        return str(self)

   253

   254

   255

class Exception(BaseException):

   256

    name = "Exception"

   257

   258

   259

class TypeError(BaseException):

   260

    name = "TypeError"

   261

   262

   263

class StandardError(Exception):

   264

    name = "StandardError"

   265

   266

   267

class LookupError(StandardError):

   268

    name = "LookupError"

   269

   270

    def toString(self):

   271

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

   272

   273

   274

class KeyError(LookupError):

   275

    name = "KeyError"

   276

   277

   278

class AttributeError(StandardError):

   279

    name = "AttributeError"

   280

   281

    def toString(self):

   282

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

   283

   284

   285

JS("""

   286

pyjslib.StopIteration = function () { };

   287

pyjslib.StopIteration.prototype = new Error();

   288

pyjslib.StopIteration.name = 'StopIteration';

   289

pyjslib.StopIteration.message = 'StopIteration';

   290

   291

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

   292

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

   293

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

   294

   295

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

   296

    return pos;

   297

}

   298

   299

pyjslib.String_join = function(data) {

   300

    var text="";

   301

   302

    if (pyjslib.isArray(data)) {

   303

        return data.join(this);

   304

    }

   305

    else if (pyjslib.isIteratable(data)) {

   306

        var iter=data.__iter__();

   307

        try {

   308

            text+=iter.next();

   309

            while (true) {

   310

                var item=iter.next();

   311

                text+=this + item;

   312

            }

   313

        }

   314

        catch (e) {

   315

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

   316

        }

   317

    }

   318

   319

    return text;

   320

}

   321

   322

pyjslib.String_isdigit = function() {

   323

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

   324

}

   325

   326

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

   327

    var do_max=false;

   328

    var start=0;

   329

    var new_str="";

   330

    var pos=0;

   331

   332

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

   333

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

   334

   335

    while (start<this.length) {

   336

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

   337

   338

        pos=this.indexOf(old, start);

   339

        if (pos<0) break;

   340

   341

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

   342

        start=pos+old.length;

   343

    }

   344

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

   345

   346

    return new_str;

   347

}

   348

   349

pyjslib.String_split = function(sep, maxsplit) {

   350

    var items=new pyjslib.List();

   351

    var do_max=false;

   352

    var subject=this;

   353

    var start=0;

   354

    var pos=0;

   355

   356

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

   357

        sep=" ";

   358

        subject=subject.strip();

   359

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

   360

    }

   361

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

   362

   363

    if (subject.length == 0) {

   364

        return items;

   365

    }

   366

   367

    while (start<subject.length) {

   368

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

   369

   370

        pos=subject.indexOf(sep, start);

   371

        if (pos<0) break;

   372

   373

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

   374

        start=pos+sep.length;

   375

    }

   376

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

   377

   378

    return items;

   379

}

   380

   381

pyjslib.String___iter__ = function() {

   382

    var i = 0;

   383

    var s = this;

   384

    return {

   385

        'next': function() {

   386

            if (i >= s.length) {

   387

                throw pyjslib.StopIteration;

   388

            }

   389

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

   390

        },

   391

        '__iter__': function() {

   392

            return this;

   393

        }

   394

    };

   395

}

   396

   397

pyjslib.String_strip = function(chars) {

   398

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

   399

}

   400

   401

pyjslib.String_lstrip = function(chars) {

   402

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

   403

   404

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

   405

}

   406

   407

pyjslib.String_rstrip = function(chars) {

   408

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

   409

   410

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

   411

}

   412

   413

pyjslib.String_startswith = function(prefix, start) {

   414

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

   415

   416

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

   417

    return false;

   418

}

   419

   420

pyjslib.abs = Math.abs;

   421

   422

""")

   423

   424

   425

class Class:

   426

    def __init__(self, name):

   427

        self.name = name

   428

   429

    def __str___(self):

   430

        return self.name

   431

   432

   433

def eq(a, b):

   434

    JS("""

   435

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

   436

        return a.__cmp__(b) == 0;

   437

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

   438

        return b.__cmp__(a) == 0;

   439

    }

   440

    return a == b;

   441

    """)

   442

   443

   444

def cmp(a, b):

   445

    if hasattr(a, "__cmp__"):

   446

        return a.__cmp__(b)

   447

    elif hasattr(b, "__cmp__"):

   448

        return -b.__cmp__(a)

   449

    if a > b:

   450

        return 1

   451

    elif b > a:

   452

        return -1

   453

    else:

   454

        return 0

   455

   456

   457

def bool(v):

   458

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

   459

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

   460

    # recursion

   461

    JS("""

   462

    if (!v) return false;

   463

    switch(typeof v){

   464

    case 'boolean':

   465

        return v;

   466

    case 'object':

   467

        if (v.__nonzero__){

   468

            return v.__nonzero__();

   469

        }else if (v.__len__){

   470

            return v.__len__()>0;

   471

        }

   472

        return true;

   473

    }

   474

    return Boolean(v);

   475

    """)

   476

   477

   478

class List:

   479

    def __init__(self, data=None):

   480

        JS("""

   481

        this.l = [];

   482

        this.extend(data);

   483

        """)

   484

   485

    def append(self, item):

   486

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

   487

   488

    def extend(self, data):

   489

        JS("""

   490

        if (pyjslib.isArray(data)) {

   491

            n = this.l.length;

   492

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

   493

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

   494

                }

   495

            }

   496

        else if (pyjslib.isIteratable(data)) {

   497

            var iter=data.__iter__();

   498

            var i=this.l.length;

   499

            try {

   500

                while (true) {

   501

                    var item=iter.next();

   502

                    this.l[i++]=item;

   503

                    }

   504

                }

   505

            catch (e) {

   506

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

   507

                }

   508

            }

   509

        """)

   510

   511

    def remove(self, value):

   512

        JS("""

   513

        var index=this.index(value);

   514

        if (index<0) return false;

   515

        this.l.splice(index, 1);

   516

        return true;

   517

        """)

   518

   519

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

   520

        JS("""

   521

        var length=this.l.length;

   522

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

   523

            if (this.l[i]==value) {

   524

                return i;