JScadNode, and some work on OpenScadNode

Author: lfagundes

docs/status-and-roadmap.rst

@@ -14,5 +14,4 @@ Roadmap
   * Improve the web viewer with workplanes, rulers, camera angles, animation control, a test runner
   * A command to create a static website with docstrings, the viewer, source and build downloads
   * A FlexibleNode class to create objects that change shape over time, with keyframes for animation
-  * A OpenJScadNode class to support OpenJScad.
-  * Separate the watcher and builder internal processes to recover from errors
+  * Improve the builder to recover from errors

docs/using-solid-node.rst

@@ -10,9 +10,10 @@ At this point, you should be able to view your project at the viewer
 - either Openscad or the web viewer - and have a source code to edit.
 
 In Solid Node, project is organized in a tree structure, with leaf nodes
-and internal nodes. **Leaf nodes** use uderlying modelling libraries, like
-**SolidPython** and **CadQuery**, to generate solid models. **Internal Nodes**
-combine children nodes in some way, like an **Assembly** or **Fusion**
+and internal nodes. **Leaf nodes** use uderlying modelling libraries, namely
+**SolidPython**, **CadQuery**, **OpenScad** and **JScad", to generate solid
+models. **Internal Nodes** combine children nodes in some way, like an
+**Assembly** or **Fusion**
 
 Each node implements the `render()` method. Leaf nodes return an object of the
 underlying library. Internal nodes `render()` should return a list of child
@@ -58,6 +59,74 @@ The same model can be obtained using **CadQuery**:
             hole = wp.workplane(offset=-50).circle(10).extrude(100)
             return cube.cut(hole)
 
+**TIP**: if you want to use CQ-editor, you can add `show_object` without
+conflicting with Solid Node:
+
+.. code-block:: python
+
+    if __name__ == '__cq_main__':
+        show_object(DemoProject().render())
+
+OpenScadNode
+------------
+
+The same model can also be obtained using an **OpenScadNode**, which is a small
+python wrapper around an OpenScad module.
+
+.. code-block:: python
+
+    from solid_node.node import OpenScadNode
+
+    class DemoProject(OpenScadNode):
+
+        scad_source = 'demo.scad'
+
+Create a file `root/demo.scad` with a module to create the model:
+
+.. code-block:: openscad
+
+    module demo() {
+      difference() {
+        translate([-25, -25, 0]) {
+          cube([50, 50, 50]);
+        }
+        cylinder(r=10, h=100);
+      }
+    }
+
+
+JScadNode
+---------
+
+Finally, the model can also be obtained using an **JScadNode**, which similarly
+to OpenScadNode, it's a python wrapper around an JScad function.
+
+.. code-block:: python
+
+    from solid_node.node import OpenScadNode
+
+    class DemoProject(OpenScadNode):
+
+        jscad_source = 'demo.js'
+
+Create a file `root/demo.js` with a module to create the model:
+
+.. code-block:: javascript
+
+    const { square, circle } = require('@jscad/modeling').primitives
+    const { subtract } = require('@jscad/modeling').booleans
+    const { extrudeLinear  } = require('@jscad/modeling').extrusions
+
+    function main() {
+      let outerSquare = square({size: 50 });
+      let innerCircle = circle({radius: 10 });
+
+      let shape = subtract(outerSquare, innerCircle);
+      return extrudeLinear({ height: 50 }, shape);
+    }
+
+    module.exports = { main }
+
 Internal Nodes
 ==============
 
@@ -85,6 +154,9 @@ Create a new file `root/clock_base.py` and create a `CadQueryNode`:
             wp = cq.Workplane("XY")
             return wp.circle(100).extrude(2)
 
+    if __name__ == '__cq_main__':
+        show_object(ClockBase().render())
+
 Now, a file `root/pointer.py` with a `Solid2Node`:
 
 .. code-block:: python

docs/why-solid-node.rst

@@ -1,9 +1,9 @@
 Why Solid Node
 ==============
 
-When designing a mechanical project with Free Software, there are some technologies available that allow parametric design, using source code to create solid structures. There's OpenScad, which uses it's own scripting language, and on top of it there is Solid Python, which allows modelling for OpenScad using Python language. Python also has CadQuery, which is more powerful and flexible for complex designs, but has a steeper learning curve. When picking which technology to use, one should consider the libraries available, and a complex project might need to assemble pieces that come from different libraries. Openscad has a native animation system that allows developing projects with moving parts, but it soon gets very slow as project grows.
+When designing a mechanical project with Free Software, there are some technologies available that allow parametric design, using source code to create solid structures. There's OpenScad, which uses it's own scripting language, and on top of it there is Solid Python, which allows modelling for OpenScad using Python language. Python also has CadQuery, which is more powerful and flexible for complex designs, but has a steeper learning curve. There's also JScad, which uses Javascript. When picking which technology to use, one should consider the libraries available, and a complex project might need to assemble pieces that come from different libraries. Openscad has a native animation system that allows developing projects with moving parts, but it soon gets very slow as project grows.
 
-Solid Node come as a framework to join all these underlying technologies together and solve performance bottlenecks. It's inspired by a web development culture, which uses frameworks like Django, React and Angular, that monitors filesystem for changes and shows results automatically. Solid Node proposes an architecture that allows building of pieces as they change, being able to handle a lot of moving parts.
+Solid Node is a framework to join all these underlying technologies together and solve performance bottlenecks. It's inspired by a web development culture, which uses frameworks like Django, React and Angular, that monitors filesystem for changes and shows results automatically. Solid Node proposes an architecture that allows building of pieces as they change, being able to handle a lot of moving parts.
 
 Solid Node also provides testing capabilities. Prototyping can take a lot of time and generate a lot of garbage, and this can be substantially reduced by being able to logically test connections between components before producing anything.
 

solid_node/node/__init__.py

@@ -10,4 +10,5 @@
 from .adapters.cadquery import CadQueryNode
 from .adapters.solid2 import Solid2Node
 from .adapters.openscad import OpenScadNode
+from .adapters.jscad import JScadNode
 from .decorators import property_as_number

solid_node/node/adapters/jscad.py

@@ -0,0 +1,52 @@
+import os
+import sys
+import time
+from solid2 import import_stl
+from subprocess import Popen
+from solid_node.node.leaf import LeafNode
+
+
+class JScadNode(LeafNode):
+    """
+    A JScad node. You just need to declare the property "jscad_source" with
+    the path of your JScad source code. It must be placed in the same directory
+    of the python file containing this node.
+
+    You need to have jscad cli tool installed in $PATH, and node dependencies
+    installed in the directory you are running solid from.
+    """
+
+    jscad_source = None
+
+    def __init__(self, name=None):
+        if not self.jscad_source:
+            raise Exception('OpenJScadNode subclass must declare "jscad_source" '
+                            'property with path with a valid OpenJScad js file')
+        module = sys.modules[self.__class__.__module__]
+        basedir = os.path.dirname(module.__file__)
+        source_path = os.path.join(basedir, self.jscad_source)
+        self.jscad_source = os.path.realpath(source_path)
+
+        super().__init__(name=name)
+
+    def get_source_file(self):
+        return self.jscad_source
+
+    def render(self):
+        return self
+
+    def as_scad(self, _):
+
+        cmd = [
+            'jscad',
+            self.jscad_source,
+            '-o', self.stl_file,
+        ]
+        print('\n' + ' '.join(cmd))
+        proc = Popen(cmd)
+        proc.communicate()
+        try:
+            os.utime(self.stl_file, (time.time(), self.mtime))
+        except FileNotFoundError:
+            pass
+        return import_stl(self.local_stl)

solid_node/node/adapters/openscad.py

@@ -1,6 +1,6 @@
 import os
+import sys
 import tempfile
-import inspect
 from solid2 import scad_render, import_scad
 from solid2.core.parse_scad import get_scad_file_as_dict
 from solid2.core.utils import resolve_scad_filename
@@ -9,31 +9,37 @@
 
 class OpenScadNode(LeafNode):
     """
-    Python wrapper around a pure scad module
+    A pure OpenScad node. You just need to declare the property "scad_source" with
+    the path of your OpenScad source code. It must be placed in the same directory
+    of the python file containing this node.
+
+    The scad file must contain a module with the same name of the file, or you
+    may specify the property "module_name" with the module name.
     """
 
     namespace = 'solid2.core.object_factory'
+    scad_source = None
+    module_name = None
 
-    def __init__(self, source, *args, name=None, **kwargs):
-        """Receives a source code and arguments, imports an OpenScad module from
-        the source and renders it using *args and **kwargs
-        The OpenScad code must implement a module with same name as file
+    def __init__(self, *args, name=None, **kwargs):
+        """Receives args, an optional name keyword argument and a list of keyword
+        arguments. The list of arguments and keyword arguments will be passed as
+        parameter to the module.
 
         Args:
-           source (str): The .scad source code, in the same folder as the python file
            *args: will be passed as arguments to the OpenScad module
            name keyword argument: the name of this node, defaul to name of the class
            **kwargs: will be passed as keyword arguments to the openscad module
         """
-        frame = inspect.currentframe().f_back
-        caller = frame.f_globals.get('__file__')
-        basedir = os.path.dirname(caller)
-        source_path = os.path.join(basedir, source)
+        module = sys.modules[self.__class__.__module__]
+        basedir = os.path.dirname(module.__file__)
+        source_path = os.path.join(basedir, self.scad_source)
         self.openscad_source = os.path.realpath(source_path)
         self.openscad_code = open(self.openscad_source).read()
         self.args = args
         self.kwargs = kwargs
-        self.module_name = source.split('/')[-1].split('.')[0]
+        if self.module_name is None:
+            self.module_name = self.openscad_source.split('/')[-1].split('.')[0]
 
         super().__init__(*args, name=name, **kwargs)
 

solid_node/node/leaf.py

@@ -11,6 +11,10 @@ class LeafNode(AbstractBaseNode):
 
     _type = 'LeafNode'
 
+    # Each LeafNode subclass can declare a namespace, and objects
+    # returned by render() must belong to that namespace
+    namespace = None
+
     @property
     def time(self):
         """Raise an exception, as leaf nodes cannot rely on time.
@@ -30,19 +34,12 @@ def as_scad(self, rendered):
         raise NotImplementedError(f"LeafNode subclass {self.__class__} must "
                                   "be able to output scad")
 
-    @property
-    def namespace(self):
-        """Each LeafNode subclass must declare a namespace, and objects
-        returned by render() must belong to that namespace"""
-        raise NotImplementedError(f"LeafNode needs to belong to a namespace-"
-                                  "constrained class.")
-
     def validate(self, rendered):
         """Check if rendered result is an object of proper namespace"""
         if type(rendered) in (list, tuple):
             raise Exception(f"{self.__class__} is a LeafNode and should return "
                             f"a {self.namespace} object, not a list")
 
-        if not type(rendered).__module__.startswith(self.namespace):
+        if self.namespace and not type(rendered).__module__.startswith(self.namespace):
             raise Exception(f"{self.__class__} is a LeafNode and should render "
                             f"as {self.namespace} child, not {type(rendered)}")