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

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

    23

    """ 

    24

    """

    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

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

class Object:

   188

    pass

   189

   190

object = Object

   191

   192

class Modload:

   193

   194

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

   195

                 parent_mod):

   196

        self.app_modlist = app_modlist

   197

        self.app_imported_fn = app_imported_fn

   198

        self.path = path

   199

        self.idx = 0;

   200

        self.dynamic = dynamic

   201

        self.parent_mod = parent_mod

   202

   203

    def next(self):

   204

   205

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

   206

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

   207

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

   208

        self.idx += 1

   209

   210

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

   211

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

   212

        else:

   213

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

   214

   215

def get_module(module_name):

   216

    ev = "__mod = %s;" % module_name

   217

    JS("pyjs_eval(ev);")

   218

    return __mod

   219

   220

def preload_app_modules(path, app_modnames, app_imported_fn, dynamic,

   221

                        parent_mod=None):

   222

   223

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

   224

    loader.next()

   225

   226

import sys

   227

   228

class BaseException:

   229

   230

    name = "BaseException"

   231

   232

    def __init__(self, *args):

   233

        self.args = args

   234

   235

    def __str__(self):

   236

        if len(self.args) is 0:

   237

            return ''

   238

        elif len(self.args) is 1:

   239

            return repr(self.args[0])

   240

        return repr(self.args)

   241

   242

    def toString(self):

   243

        return str(self)

   244

   245

class Exception(BaseException):

   246

   247

    name = "Exception"

   248

   249

class TypeError(BaseException):

   250

    name = "TypeError"

   251

   252

class StandardError(Exception):

   253

    name = "StandardError"

   254

   255

class LookupError(StandardError):

   256

    name = "LookupError"

   257

   258

    def toString(self):

   259

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

   260

   261

class KeyError(LookupError):

   262

    name = "KeyError"

   263

   264

class AttributeError(StandardError):

   265

   266

    name = "AttributeError"

   267

   268

    def toString(self):

   269

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

   270

   271

JS("""

   272

pyjslib.StopIteration = function () { };

   273

pyjslib.StopIteration.prototype = new Error();

   274

pyjslib.StopIteration.name = 'StopIteration';

   275

pyjslib.StopIteration.message = 'StopIteration';

   276

   277

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

   278

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

   279

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

   280

   281

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

   282

    return pos;

   283

}

   284

   285

pyjslib.String_join = function(data) {

   286

    var text="";

   287

   288

    if (pyjslib.isArray(data)) {

   289

        return data.join(this);

   290

    }

   291

    else if (pyjslib.isIteratable(data)) {

   292

        var iter=data.__iter__();

   293

        try {

   294

            text+=iter.next();

   295

            while (true) {

   296

                var item=iter.next();

   297

                text+=this + item;

   298

            }

   299

        }

   300

        catch (e) {

   301

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

   302

        }

   303

    }

   304

   305

    return text;

   306

}

   307

   308

pyjslib.String_isdigit = function() {

   309

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

   310

}

   311

   312

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

   313

    var do_max=false;

   314

    var start=0;

   315

    var new_str="";

   316

    var pos=0;

   317

   318

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

   319

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

   320

   321

    while (start<this.length) {

   322

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

   323

   324

        pos=this.indexOf(old, start);

   325

        if (pos<0) break;

   326

   327

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

   328

        start=pos+old.length;

   329

    }

   330

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

   331

   332

    return new_str;

   333

}

   334

   335

pyjslib.String_split = function(sep, maxsplit) {

   336

    var items=new pyjslib.List();

   337

    var do_max=false;

   338

    var subject=this;

   339

    var start=0;

   340

    var pos=0;

   341

   342

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

   343

        sep=" ";

   344

        subject=subject.strip();

   345

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

   346

    }

   347

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

   348

   349

    if (subject.length == 0) {

   350

        return items;

   351

    }

   352

   353

    while (start<subject.length) {

   354

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

   355

   356

        pos=subject.indexOf(sep, start);

   357

        if (pos<0) break;

   358

   359

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

   360

        start=pos+sep.length;

   361

    }

   362

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

   363

   364

    return items;

   365

}

   366

   367

pyjslib.String___iter__ = function() {

   368

    var i = 0;

   369

    var s = this;

   370

    return {

   371

        'next': function() {

   372

            if (i >= s.length) {

   373

                throw pyjslib.StopIteration;

   374

            }

   375

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

   376

        },

   377

        '__iter__': function() {

   378

            return this;

   379

        }

   380

    };

   381

}

   382

   383

pyjslib.String_strip = function(chars) {

   384

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

   385

}

   386

   387

pyjslib.String_lstrip = function(chars) {

   388

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

   389

   390

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

   391

}

   392

   393

pyjslib.String_rstrip = function(chars) {

   394

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

   395

   396

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

   397

}

   398

   399

pyjslib.String_startswith = function(prefix, start) {

   400

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

   401

   402

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

   403

    return false;

   404

}

   405

   406

pyjslib.abs = Math.abs;

   407

   408

""")

   409

   410

class Class:

   411

    def __init__(self, name):

   412

        self.name = name

   413

   414

    def __str___(self):

   415

        return self.name

   416

   417

def eq(a,b):

   418

    JS("""

   419

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

   420

        return a.__cmp__(b) == 0;

   421

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

   422

        return b.__cmp__(a) == 0;

   423

    }

   424

    return a == b;

   425

    """)

   426

   427

def cmp(a,b):

   428

    if hasattr(a, "__cmp__"):

   429

        return a.__cmp__(b)

   430

    elif hasattr(b, "__cmp__"):

   431

        return -b.__cmp__(a)

   432

    if a > b:

   433

        return 1

   434

    elif b > a:

   435

        return -1

   436

    else:

   437

        return 0

   438

   439

def bool(v):

   440

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

   441

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

   442

    # recursion

   443

    JS("""

   444

    if (!v) return false;

   445

    switch(typeof v){

   446

    case 'boolean':

   447

        return v;

   448

    case 'object':

   449

        if (v.__nonzero__){

   450

            return v.__nonzero__();

   451

        }else if (v.__len__){

   452

            return v.__len__()>0;

   453

        }

   454

        return true;

   455

    }

   456

    return Boolean(v);

   457

    """)

   458

   459

class List:

   460

    def __init__(self, data=None):

   461

        JS("""

   462

        this.l = [];

   463

        this.extend(data);

   464

        """)

   465

   466

    def append(self, item):

   467

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

   468

   469

    def extend(self, data):

   470

        JS("""

   471

        if (pyjslib.isArray(data)) {

   472

            n = this.l.length;

   473

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

   474

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

   475

                }

   476

            }

   477

        else if (pyjslib.isIteratable(data)) {

   478

            var iter=data.__iter__();

   479

            var i=this.l.length;

   480

            try {

   481

                while (true) {

   482

                    var item=iter.next();

   483

                    this.l[i++]=item;

   484

                    }

   485

                }

   486

            catch (e) {

   487

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

   488

                }

   489

            }

   490

        """)

   491

   492

    def remove(self, value):

   493

        JS("""

   494

        var index=this.index(value);

   495

        if (index<0) return false;

   496

        this.l.splice(index, 1);

   497

        return true;

   498

        """)

   499

   500

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

   501

        JS("""

   502

        var length=this.l.length;

   503

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

   504

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

   505

                return i;

   506

                }

   507

            }

   508

        return -1;

   509

        """)

   510

   511

    def insert(self, index, value):

   512

        JS("""    var a = this.l; this.l=a.slice(0, index).concat(value, a.slice(index));""")

   513

   514

    def pop(self, index = -1):

   515

        JS("""

   516

        if (index<0) index = this.l.length + index;

   517

        var a = this.l[index];

   518

        this.l.splice(index, 1);

   519

        return a;

   520

        """)

   521

   522

    def __cmp__(self, l):

   523

        if not isinstance(l, List):

   524

            return -1

   525

        ll = len(self) - len(l)

   526

        if ll != 0:

   527

            return ll

   528

        for x in range(len(l)):

   529

            ll = cmp(self.__getitem__(x), l[x])