propane 0.6.0-java → 0.7.0-java

data/src/monkstone/PropaneLibrary.java

@@ -28,7 +28,7 @@ public class PropaneLibrary implements Library{
      * @param runtime
      */
     public static void load(final Ruby runtime) {
-        MathTool.createMathTool(runtime);
+        MathToolModule.createMathToolModule(runtime);
         Deglut.createDeglut(runtime);
         Vec2.createVec2(runtime);
         Vec3.createVec3(runtime);

data/src/monkstone/WatchSketchDir.java

@@ -0,0 +1,190 @@
+/**
+ * This class allows JRubyArt to watch for changes to sketch files
+ * specifically those with a 'rb' or 'glsl' extension requires user to supply
+ * a path String and code listener to constructor. The code listener should 
+ * accept a filesystem WatchEvent
+ */
+
+/*
+ * This code is a modified version of WatchDir.java
+ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *   - Neither the name of Oracle nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package monkstone;
+
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import static java.nio.file.StandardWatchEventKinds.*;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchKey;
+import java.nio.file.WatchService;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Example to watch a directory (or tree) for changes to files.
+ */
+public class WatchSketchDir {
+
+    private final WatchService watcher;
+    private final Map<WatchKey, Path> keys;
+    private boolean trace = false;
+    
+    @SuppressWarnings("unchecked")
+    static <T> WatchEvent<T> cast(WatchEvent<?> event) {
+        return (WatchEvent<T>) event;
+    }
+
+
+    /**
+     * Register the given directory with the WatchService
+     */
+    private void register(Path dir) throws IOException {
+        WatchKey key = dir.register(watcher, ENTRY_MODIFY);
+        if (trace) {
+            Path prev = keys.get(key);
+            if (prev == null) {
+                System.out.format("register: %s\n", dir);
+            } else if (!dir.equals(prev)) {
+                System.out.format("update: %s -> %s\n", prev, dir);
+            }
+        }
+        keys.put(key, dir);
+    }
+
+    /**
+     * Register the given directory, and all its sub-directories, with the
+     * WatchService.
+     */
+    private void registerAll(final Path start) throws IOException {
+        // register directory and sub-directories
+        Files.walkFileTree(start, new SimpleFileVisitor<Path>() {
+            @Override
+            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
+                    throws IOException {
+                register(dir);
+                return FileVisitResult.CONTINUE;
+            }
+        });
+    }
+    
+    static final WatchSketchDir watch(String dir) throws IOException{
+        return new WatchSketchDir(dir);
+    }
+
+    /**
+     * Creates a WatchService and registers the given directory
+     * @param dir String
+     * @param obj CodeListener
+     * @throws IOException
+     */
+    private WatchSketchDir(String dir) throws IOException {
+        this(Paths.get(dir));
+    }
+
+    /**
+     * Creates a WatchService and registers the given directory
+     *
+     * @param dir Path
+     * @param obj CodeListener
+     * @throws java.io.IOException
+     */
+    private WatchSketchDir(Path dir) throws IOException {
+        this.watcher = FileSystems.getDefault().newWatchService();
+        this.keys = new HashMap<>();
+
+        System.out.format("Scanning Codebase\n", dir);
+        registerAll(dir);
+        System.out.format("Watching %s\n", dir);
+
+        // enable trace after initial registration
+        this.trace = true;
+    }
+
+    /**
+     * Process all events for keys queued to the watcher
+     */
+    public void addListener(CodeListener obj) {
+        for (;;) {
+
+            // wait for key to be signalled
+            WatchKey key;
+            try {
+                key = watcher.take();
+            } catch (InterruptedException x) {
+                return;
+            }
+
+            Path dir = keys.get(key);
+            if (dir == null) {
+                System.err.println("WatchKey not recognized!!");
+                continue;
+            }
+
+            key.pollEvents().stream().forEach((WatchEvent<?> event) -> {
+                WatchEvent.Kind kind = event.kind();
+                // TBD - provide example of how OVERFLOW event is handled
+                if (!(kind == OVERFLOW)) {
+                    // Context for directory entry event is the file name of entry
+                    WatchEvent<Path> ev = cast(event);
+                    Path name = ev.context();
+                    Path child = dir.resolve(name);
+                    if (kind == ENTRY_MODIFY){
+                    if (child.toFile().getAbsolutePath().endsWith(".rb")
+                            || child.toFile().getAbsolutePath().endsWith(".glsl")) {
+    
+                        obj.code_event(event);
+                        key.reset();
+                    }
+                    }
+                    // if directory is created, and watching recursively, then
+                    // register it and its sub-directories
+                }
+            });
+
+            // reset key and remove from set if directory no longer accessible
+            boolean valid = key.reset();
+            if (!valid) {
+                keys.remove(key);
+
+                // all directories are inaccessible
+                if (keys.isEmpty()) {
+                    break;
+                }
+            }
+        }
+    }    
+
+}

data/src/monkstone/fastmath/Deglut.java

@@ -1,10 +1,29 @@
+/* 
+ * Copyright (c) 2015-16 Martin Prout
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
 package monkstone.fastmath;
 
 import org.jruby.Ruby;
-import org.jruby.RubyClass;
+import org.jruby.RubyInteger;
 import org.jruby.RubyModule;
-import org.jruby.RubyObject;
-import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyModule;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -13,8 +32,8 @@ import org.jruby.runtime.builtin.IRubyObject;
 *
 * @author Martin Prout
 */
-@JRubyClass(name = "DegLut")
-public class Deglut extends RubyObject {
+@JRubyModule(name = "DegLut")
+public class Deglut {
   
   /**
   * Lookup table for degree cosine/sine, has a fixed precision 1.0
@@ -34,10 +53,10 @@ public class Deglut extends RubyObject {
   
   private final static int NINETY = 90;
   private final static int FULL = 360;
-    private static final long serialVersionUID = -1466528933765940101L;
+  private static final long serialVersionUID = -1466528933765940101L;
   
   /**
-  * Initialise sin table with values (first quadrant only)
+  * Initialize sin table with values (first quadrant only)
   */
   public static final void initTable() {
     if (initialized == false) {
@@ -46,41 +65,31 @@ public class Deglut extends RubyObject {
       }
       initialized = true;
     }
-  }  
-  
-  
+  }
+    
   /**
   *
-  * @param runtime
+  * @param runtime Ruby
   */
   
   public static void createDeglut(final Ruby runtime){
     RubyModule deglutModule = runtime.defineModule("DegLut");
     deglutModule.defineAnnotatedMethods(Deglut.class);
     Deglut.initTable();
-  }  
-  
-  
-  /**
-  *
-  * @param runtime
-  * @param klass
-  */
-  private Deglut(Ruby runtime, RubyClass klass) {
-    super(runtime, klass);
   }
-  
+    
+ 
   /**
   *
-  * @param context
-  * @param klazz
-  * @param other
-  * @return sin float
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param other IRubyObject degrees
+  * @return sin IRubyObject
   */
-  @JRubyMethod(name = "sin", meta = true)
+  @JRubyMethod(name = "sin", module = true)
   
-  public static IRubyObject sin(ThreadContext context, IRubyObject klazz, IRubyObject other) {
-    int thet = (Integer) other.toJava(Integer.class);
+  public static IRubyObject sin(ThreadContext context, IRubyObject recv, IRubyObject other) {
+    int thet = (int) ((RubyInteger)other).getLongValue();
     while (thet < 0) {
       thet += FULL; // Needed because negative modulus plays badly in java
     }
@@ -89,19 +98,19 @@ public class Deglut extends RubyObject {
     double result = (theta < NINETY) ? SIN_DEG_LUT[y] : (theta < 180)
     ? SIN_DEG_LUT[NINETY - y] : (theta < 270)
     ? -SIN_DEG_LUT[y] : -SIN_DEG_LUT[NINETY - y];
-    return context.getRuntime().newFloat(result);
+    return context.runtime.newFloat(result);
   }
   
   /**
   *
-  * @param context
-  * @param klazz
-  * @param other
-  * @return cos float
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param other IRubyObject degrees
+  * @return cos IRubyObject
   */
-  @JRubyMethod(name = "cos", meta = true)
-  public static IRubyObject cos(ThreadContext context, IRubyObject klazz, IRubyObject other) {
-    int thet = (Integer) other.toJava(Integer.class);
+  @JRubyMethod(name = "cos", module = true)
+  public static IRubyObject cos(ThreadContext context, IRubyObject recv, IRubyObject other) {
+    int thet = (int) ((RubyInteger)other).getLongValue();
     while (thet < 0) {
       thet += FULL; // Needed because negative modulus plays badly in java
     }
@@ -110,6 +119,6 @@ public class Deglut extends RubyObject {
     double result = (theta < NINETY) ? SIN_DEG_LUT[NINETY - y] : (theta < 180)
     ? -SIN_DEG_LUT[y] : (theta < 270)
     ? -SIN_DEG_LUT[NINETY - y] : SIN_DEG_LUT[y];
-    return context.getRuntime().newFloat(result);
+    return context.runtime.newFloat(result);
   }  
 }

data/src/monkstone/fastmath/package-info.java

@@ -0,0 +1,6 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package monkstone.fastmath;

data/src/monkstone/vecmath/AppRender.java

@@ -12,7 +12,7 @@ public class AppRender implements JRender {
 
     /**
      *
-     * @param app
+     * @param app PApplet
      */
     public AppRender(final PApplet app) {
         this.app = app;
@@ -20,8 +20,8 @@ public class AppRender implements JRender {
 
     /**
      *
-     * @param x
-     * @param y
+     * @param x double
+     * @param y double
      */
     @Override
     public void vertex(double x, double y) {
@@ -30,8 +30,8 @@ public class AppRender implements JRender {
     
     /**
      *
-     * @param x
-     * @param y
+     * @param x double
+     * @param y double
      */
     @Override
     public void curveVertex(double x, double y) {
@@ -40,9 +40,9 @@ public class AppRender implements JRender {
 
     /**
      *
-     * @param x
-     * @param y
-     * @param z
+     * @param x double
+     * @param y double
+     * @param z double
      */
     @Override
     public void vertex(double x, double y, double z) {
@@ -51,9 +51,9 @@ public class AppRender implements JRender {
 
     /**
      *
-     * @param x
-     * @param y
-     * @param z
+     * @param x double
+     * @param y double
+     * @param z double
      */
     @Override
     public void normal(double x, double y, double z) {
@@ -62,11 +62,11 @@ public class AppRender implements JRender {
 
     /**
      *
-     * @param x
-     * @param y
-     * @param z
-     * @param u
-     * @param v
+     * @param x double
+     * @param y double
+     * @param z double
+     * @param u double
+     * @param v double
      */
     @Override
     public void vertex(double x, double y, double z, double u, double v) {
@@ -75,13 +75,12 @@ public class AppRender implements JRender {
     
     /**
      *
-     * @param x
-     * @param y
-     * @param z
+     * @param x double
+     * @param y double
+     * @param z double
      */
     @Override
     public void curveVertex(double x, double y, double z) {
         app.curveVertex((float) x, (float) y, (float) z);
     }
-
 }

data/src/monkstone/vecmath/JRender.java

@@ -4,53 +4,53 @@ package monkstone.vecmath;
  *
  * @author Martin Prout
  */
-public interface JRender {  
+public interface JRender {
 
     /**
      *
-     * @param x
-     * @param y
+     * @param x double
+     * @param y double
      */
     public void vertex(double x, double y);
 
     /**
      *
-     * @param x
-     * @param y
+     * @param x double
+     * @param y double
      */
     public void curveVertex(double x, double y);
 
     /**
      *
-     * @param x
-     * @param y
-     * @param z
+     * @param x double
+     * @param y double
+     * @param z double
      */
     public void vertex(double x, double y, double z);
 
     /**
      *
-     * @param x
-     * @param y
-     * @param z
-     * @param u
-     * @param v
+     * @param x double
+     * @param y double
+     * @param z double
+     * @param u double
+     * @param v double
      */
     public void vertex(double x, double y, double z, double u, double v);
 
     /**
      *
-     * @param x
-     * @param y
-     * @param z
+     * @param x double
+     * @param y double
+     * @param z double
      */
     public void curveVertex(double x, double y, double z);
 
     /**
      *
-     * @param x
-     * @param y
-     * @param z
+     * @param x double
+     * @param y double
+     * @param z double
      */
     public void normal(double x, double y, double z);
 }