Merge branch 'master' of github.com:skulpt/skulpt

Author: LeszekSwirski

CONTRIBUTING.md

@@ -19,6 +19,7 @@ This is the contribute.md of our project. Great to have you here. Here are a few
 This section includes ways to get started with your open source project. Include links to documentation and to different communication channels:
 
 * github: Lots of good discussion happens around pull requests and bug reports
+* [gitter discussion](https://gitter.im/skulpt/skulpt?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 * [Mailing list](https://groups.google.com/forum/#!forum/skulpt)
 * IRC channel: [#skulpt](http://webchat.freenode.net/?channels=skulpt)
 * Blog: Some stuff about getting started is on [Brad's blog](http://reputablejournal.com)

HACKING.rst

@@ -509,6 +509,62 @@ The Sk.builtin.func method creates a function.  For module creation we typically
 
 Well, I think this should be enough to get you going.  Its worth repeating, if you made it this far, don't forget to call m docbi or m dist after you make changes in your module, its easy to get into the mode of thinking that the new javascript is automatically loaded.  But skulpt-stdlib.js is not automatically rebuilt!
 
+Importing/Using a module in another module
+------------------------------------------
+
+While working on the namedtuple factory in the collections module I needed to add code to make
+sure that the fields named in the named tuple did not duplicate python keywords.  while I was
+looking around for a list of keywords I discovered that there already was a list of keywords
+in the keyword module.  Why not use that?  A couple of problems:
+
+* How do you import a module into another module?  Especially under the condition
+where you are writing a module in javascript and the module you want to include is a python
+module?
+
+* How do you call a function that was imported from a python module?  Here is the snippet
+that demonstrates
+
+.. code-block:: javascript
+
+    var keywds = Sk.importModule("keyword", false, false);
+
+    mod.namedtuple = function (name, fields) {
+        var nm = Sk.ffi.remapToJs(name);
+        // fields could be a string or a tuple or list of strings
+        var flds = Sk.ffi.remapToJs(fields);
+
+        if (typeof(flds) === 'string') {
+            flds = flds.split(/\s+/);
+        }
+        // use the keyword module function iskeyword
+        for (i = 0; i < flds.length; i++) {
+            if (Sk.ffi.remapToJs(Sk.misceval.callsim(keywds.$d['iskeyword'],Sk.ffi.remapToPy(flds[i])))) {
+                throw new Sk.builtin.ValueError("Type names and field names cannot be a keyword: " + flds[i]);
+            }
+        }
+
+The importing part is easy:   ``Sk.importModule(name, dumpJS, canSuspend)``
+
+The not-so-obvious part is the
+line:  ``Sk.ffi.remapToJs(Sk.misceval.callsim(keywds.$d['iskeyword'],Sk.ffi.remapToPy(flds[i])))``
+
+Working inside out:  We use ``Sk.misceval.callsim`` to call the python function ``iskeyword``  which we
+retrieve from the module's dictionary of methods ``$d``  Because we are calling a Python function we need
+to remap the parameter from a javascript string to a Python string object.  Hence the ``remapToPy`` call
+in the parameter.  Since ``iskeyword`` will return a Python bool object we need to remap that back
+to javscript for our if statement.
+
+You can use a similar strategy for creating an instance of a class:
+
+.. code-block:: javascript
+
+   var io = Sk.importModule("io", false, false);
+   var stdin = Sk.misceval.callsim(io.$d["TextIOWrapper"]);
+
+
+Seems like a lot of work to check for a keyword in an array.  But knowing how to do this for much more
+complicated methods in other modules will pay off.
+
 
 Debugging
 ---------

skulpt.py

@@ -91,6 +91,7 @@ def bowerProperty(name):
         'src/slice.js',
         'src/set.js',
         'src/module.js',
+        'src/structseq.js',
         'src/generator.js',
         'src/file.js',
         'src/ffi.js',

src/abstract.js

@@ -28,7 +28,7 @@ Sk.abstr.unop_type_error = function (v, name) {
         uop = {
             "UAdd"  : "+",
             "USub"  : "-",
-            "Inver": "~"
+            "Invert": "~"
         }[name];
 
     throw new Sk.builtin.TypeError("bad operand type for unary " + uop + ": '" + vtypename + "'");
@@ -136,7 +136,6 @@ Sk.abstr.uoNameToSlotFunc_ = function (obj, name) {
     if (obj === null) {
         return undefined;
     }
-
     switch (name) {
     case "USub":
         return obj.nb$negative ? obj.nb$negative : obj["__neg__"];
@@ -242,12 +241,6 @@ Sk.abstr.numOpAndPromote = function (a, b, opfn) {
     }
 
     if (a.constructor === Sk.builtin.lng) {
-//      if (b.constructor == Sk.builtin.nmber)
-//          if (b.skType == Sk.builtin.nmber.float$) {
-//              var tmp = new Sk.builtin.nmber(a.tp$str(), Sk.builtin.nmber.float$);
-//              return [tmp, b];
-//          } else
-//              return [a, b.v];
         return [a, b];
     } else if (a.constructor === Sk.builtin.nmber) {
         return [a, b];

src/biginteger.js

@@ -900,7 +900,6 @@ Sk.builtin.biginteger.prototype.bnIntValue = function () {
     else if (this.t === 0) {
         return 0;
     }
-// assumes 16 < DB < 32
     return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0];
 };
 
@@ -1439,7 +1438,6 @@ Sk.builtin.biginteger.prototype.bnpMultiplyUpperTo = function (a, n, r) {
  * @extends Sk.builtin.biginteger
  */
 Sk.builtin.biginteger.Barrett = function (m) {
-// setup Barrett
     this.r2 = Sk.builtin.biginteger.nbi();
     this.q3 = Sk.builtin.biginteger.nbi();
     Sk.builtin.biginteger.ONE.dlShiftTo(2 * m.t, this.r2);
@@ -1537,7 +1535,6 @@ Sk.builtin.biginteger.prototype.bnModPow = function (e, m) {
         z = new Sk.builtin.biginteger.Montgomery(m);
     }
 
-// precomputation
     g = [];
     n = 3;
     k1 = k - 1;

src/builtin.js

@@ -128,7 +128,7 @@ Sk.builtin.asnum$nofloat = function (a) {
         a = a.toString();
     }
 
-//	Sk.debugout("INITIAL: " + a);
+    //	Sk.debugout("INITIAL: " + a);
 
     //	If not a float, great, just return this
     if (a.indexOf(".") < 0 && a.indexOf("e") < 0 && a.indexOf("E") < 0) {
@@ -147,17 +147,10 @@ Sk.builtin.asnum$nofloat = function (a) {
         mantissa = a;
     }
 
-//	Sk.debugout("e:" + expon);
-
     expon = parseInt(expon, 10);
 
-//	Sk.debugout("MANTISSA:" + mantissa);
-//	Sk.debugout("EXPONENT:" + expon);
-
     decimal = mantissa.indexOf(".");
 
-//	Sk.debugout("DECIMAL: " + decimal);
-
     //	Simplest case, no decimal
     if (decimal < 0) {
         if (expon >= 0) {
@@ -187,27 +180,17 @@ Sk.builtin.asnum$nofloat = function (a) {
         mantissa = mantissa.substr(0, decimal);
     }
 
-//	Sk.debugout("NO DECIMAL: " + mantissa);
-
     decimal = decimal + expon;
-
-//	Sk.debugout("MOVE DECIM: " + decimal);
-
     while (decimal > mantissa.length) {
         mantissa += "0";
     }
 
-//	Sk.debugout("PADDED    : " + mantissa);
-
     if (decimal <= 0) {
         mantissa = 0;
     } else {
         mantissa = mantissa.substr(0, decimal);
     }
 
-//	Sk.debugout("LENGTH: " + mantissa.length);
-//	Sk.debugout("RETURN: " + mantissa);
-
     return mantissa;
 };
 goog.exportSymbol("Sk.builtin.asnum$nofloat", Sk.builtin.asnum$nofloat);
@@ -750,6 +733,21 @@ Sk.builtin.getattr = function getattr (obj, name, default_) {
     return ret;
 };
 
+Sk.builtin.setattr = function setattr (obj, name, value) {
+
+    Sk.builtin.pyCheckArgs("setattr", arguments, 3, 3);
+    if (!Sk.builtin.checkString(name)) {
+        throw new Sk.builtin.TypeError("attribute name must be string");
+    }
+    if (obj.tp$setattr) {
+        obj.tp$setattr(Sk.ffi.remapToJs(name), value);
+    } else {
+        throw new Sk.builtin.AttributeError("object has no attribute " + Sk.ffi.remapToJs(name));
+    }
+
+    return Sk.builtin.none.none$;
+};
+
 Sk.builtin.raw_input = function (prompt) {
     var x, resolution, susp;
 

src/builtindict.js

@@ -68,13 +68,14 @@ Sk.builtins = {
     "type"      : Sk.builtin.type,
     "input"     : Sk.builtin.input,
     "raw_input" : Sk.builtin.raw_input,
+    "setattr"   : Sk.builtin.setattr,
     /*'read': Sk.builtin.read,*/
     "jseval"    : Sk.builtin.jseval,
     "jsmillis"  : Sk.builtin.jsmillis,
     "quit"      : Sk.builtin.quit,
     "exit"      : Sk.builtin.quit,
 
-// Functions below are not implemented
+    // Functions below are not implemented
     "bytearray" : Sk.builtin.bytearray,
     "callable"  : Sk.builtin.callable,
     "complex"   : Sk.builtin.complex,

src/dict.js

@@ -386,83 +386,70 @@ Sk.builtin.dict.prototype["values"] = new Sk.builtin.func(function (self) {
     return new Sk.builtin.list(ret);
 });
 
+Sk.builtin.dict.prototype["clear"] = new Sk.builtin.func(function (self) {
+    var k;
+    var iter;
+
+    for (iter = self.tp$iter(), k = iter.tp$iternext();
+         k !== undefined;
+         k = iter.tp$iternext()) {
+        self.mp$del_subscript(k);
+    }
+});
+
+Sk.builtin.dict.prototype["setdefault"] = new Sk.builtin.func(function (self, key, default_) {
+    try {
+        return self.mp$subscript(key);
+    }
+    catch (e) {
+        if (default_ === undefined) {
+            default_ = Sk.builtin.none.none$;
+        }
+        self.mp$ass_subscript(key, default_);
+        return default_;
+    }
+});
+
+Sk.builtin.dict.prototype["copy"] = new Sk.builtin.func(function (self) {
+    throw new Sk.builtin.NotImplementedError("dict.copy is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["fromkeys"] = new Sk.builtin.func(function (seq, value) {
+    throw new Sk.builtin.NotImplementedError("dict.fromkeys is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["iteritems"] = new Sk.builtin.func(function (self) {
+    throw new Sk.builtin.NotImplementedError("dict.iteritems is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["iterkeys"] = new Sk.builtin.func(function (self) {
+    throw new Sk.builtin.NotImplementedError("dict.iterkeys is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["itervalues"] = new Sk.builtin.func(function (self) {
+    throw new Sk.builtin.NotImplementedError("dict.itervalues is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["popitem"] = new Sk.builtin.func(function (self) {
+    throw new Sk.builtin.NotImplementedError("dict.popitem is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["update"] = new Sk.builtin.func(function (self, other) {
+    throw new Sk.builtin.NotImplementedError("dict.update is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["viewitems"] = new Sk.builtin.func(function (self) {
+    throw new Sk.builtin.NotImplementedError("dict.viewitems is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["viewkeys"] = new Sk.builtin.func(function (self) {
+    throw new Sk.builtin.NotImplementedError("dict.viewkeys is not yet implemented in Skulpt");
+});
+
+Sk.builtin.dict.prototype["viewvalues"] = new Sk.builtin.func(function (self) {
+    throw new Sk.builtin.NotImplementedError("dict.viewvalues is not yet implemented in Skulpt");
+});
+
 Sk.builtin.dict.prototype.tp$name = "dict";
 
 goog.exportSymbol("Sk.builtin.dict", Sk.builtin.dict);
-
-/*
-
- $.prototype.clear = function() { throw "todo; dict.clear"; };
- $.prototype.copy = function() { throw "todo; dict.copy"; };
- $.prototype.fromkeys = function() { throw "todo; dict.fromkeys"; };
- $.prototype.get = function() { throw "todo; dict.get"; };
-
- $.prototype.has_key = function(key)
- {
- return this.hasOwnProperty(kf(key));
- };
-
- $.prototype.items = function() { throw "todo; dict.items"; };
- $.prototype.iteritems = function() { throw "todo; dict.iteritems"; };
- $.prototype.iterkeys = function() { throw "todo; dict.iterkeys"; };
- $.prototype.itervalues = function() { throw "todo; dict.itervalues"; };
- $.prototype.keys = function() { throw "todo; dict.keys"; };
- $.prototype.pop = function() { throw "todo; dict.pop"; };
- $.prototype.popitem = function() { throw "todo; dict.popitem"; };
- $.prototype.setdefault = function() { throw "todo; dict.setdefault"; };
- $.prototype.update = function() { throw "todo; dict.update"; };
- $.prototype.values = function() { throw "todo; dict.values"; };
-
- $.prototype.__getitem__ = function(key)
- {
- var entry = this[kf(key)];
- return typeof entry === 'undefined' ? undefined : entry.rhs;
- };
-
- $.prototype.__delitem__ = function(key)
- {
- var k = kf(key);
-
- if (this.hasOwnProperty(k))
- {
- this.size -= 1;
- delete this[k];
- }
-
- return this;
- };
-
- $.prototype.__class__ = new Sk.builtin.type('dict', [Sk.types.object], {});
-
- $.prototype.__iter__ = function()
- {
- var allkeys = [];
- for (var k in this)
- {
- if (this.hasOwnProperty(k))
- {
- var i = this[k];
- if (i && i.hasOwnProperty('lhs')) // skip internal stuff. todo; merge pyobj and this
- {
- allkeys.push(k);
- }
- }
- }
- //print(allkeys);
-
- var ret =
- {
- __iter__: function() { return ret; },
- $obj: this,
- $index: 0,
- $keys: allkeys,
- next: function()
- {
- // todo; StopIteration
- if (ret.$index >= ret.$keys.length) return undefined;
- return ret.$obj[ret.$keys[ret.$index++]].lhs;
- }
- };
- return ret;
- };
- */