diametric 0.1.1 → 0.1.2

data/ext/diametric/DiametricCommon.java

@@ -0,0 +1,165 @@
+package diametric;
+
+import java.util.Iterator;
+
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import clojure.lang.PersistentVector;
+import clojure.lang.Var;
+
+class DiametricCommon {
+    IRubyObject collect(ThreadContext context, Block block, Iterator<Object> itr) {
+        RubyArray ary = context.getRuntime().newArray();
+        while (itr.hasNext()) {
+            IRubyObject next = DiametricUtils.convertJavaToRuby(context, itr.next());
+            ary.callMethod(context, "<<", block.yield(context, next));
+        }
+        return ary;
+    }
+
+    IRubyObject count(ThreadContext context, IRubyObject arg, Object target) {
+        try {
+            Var count_value_fn = null;
+            if (DiametricService.fnMap.containsKey("count-value")) {
+                count_value_fn = DiametricService.fnMap.get("count-value");
+            } else {
+                Var var = DiametricService.getFn("clojure.core", "load-string");
+                count_value_fn = (Var)var.invoke("(defn count-value [v array] (count (filterv (partial = v) array)))");
+                DiametricService.fnMap.put("count-value", count_value_fn);
+            }
+            Object value = DiametricUtils.convertRubyToJava(context, arg);
+            return context.getRuntime().newFixnum((Integer)count_value_fn.invoke(value, target));
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    IRubyObject count(ThreadContext context, Block block, Iterator<Object> itr) {
+        Long count = 0L;
+        while (itr.hasNext()) {
+            IRubyObject next = DiametricUtils.convertJavaToRuby(context, itr.next());
+            if (block.yield(context, next).isTrue()) {
+                count++;
+            }
+        }
+        return context.getRuntime().newFixnum(count);
+    }
+
+    IRubyObject empty_p(ThreadContext context, Object target) {
+        try {
+            Var var = DiametricService.getFn("clojure.core", "empty?");
+            if ((Boolean)var.invoke(target)) {
+                return context.getRuntime().getTrue();
+            } else {
+                return context.getRuntime().getFalse();
+            }
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    IRubyObject drop_or_take(ThreadContext context, Long n, Object target) {
+        try {
+            Var drop_or_take_fn = null;
+            if (DiametricService.fnMap.containsKey("drop-or-take")) {
+                drop_or_take_fn = DiametricService.fnMap.get("drop-or-take");
+            } else {
+                Var var = DiametricService.getFn("clojure.core", "load-string");
+                drop_or_take_fn = (Var)var.invoke("(defn drop-or-take [n target] (apply vector (drop n target)))");
+                DiametricService.fnMap.put("drop-or-take", drop_or_take_fn);
+            }
+            PersistentVector value = (PersistentVector)drop_or_take_fn.invoke(n, target);
+            RubyClass clazz = (RubyClass) context.getRuntime().getClassFromPath("Diametric::Persistence::Collection");
+            DiametricCollection ruby_collection = (DiametricCollection)clazz.allocate();
+            ruby_collection.init(value);
+            return ruby_collection;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    IRubyObject drop_while(ThreadContext context, Block block, Iterator<Object> itr) {
+        RubyArray ary = context.getRuntime().newArray();
+        while (itr.hasNext()) {
+            IRubyObject next = DiametricUtils.convertJavaToRuby(context, itr.next());
+            if (block.yield(context, next).isTrue()) {
+                continue;
+            } else {
+                ary.callMethod(context, "<<", next);
+                break;
+            }
+        }
+        while (itr.hasNext()) {
+            ary.callMethod(context, "<<", DiametricUtils.convertJavaToRuby(context, itr.next()));
+        }
+        return ary;
+    }
+
+    void each(ThreadContext context, Block block, Iterator<Object> itr) {
+        while (itr.hasNext()) {
+            IRubyObject next = DiametricUtils.convertJavaToRuby(context, itr.next());
+            block.yield(context, next);
+        }
+    }
+
+    IRubyObject first(ThreadContext context, Object target) {
+        try {
+            Var var = DiametricService.getFn("clojure.core", "first");
+            return DiametricUtils.convertJavaToRuby(context, var.invoke(target));
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+    
+    IRubyObject first(ThreadContext context, Long n, Object target) {
+        try {
+            Var first_n_fn = null;
+            if (DiametricService.fnMap.containsKey("first-n")) {
+                first_n_fn = DiametricService.fnMap.get("first-n");
+            } else {
+                Var var = DiametricService.getFn("clojure.core", "load-string");
+                first_n_fn = (Var)var.invoke("(defn first-n [n target] (apply vector (take n target)))");
+                DiametricService.fnMap.put("first-n", first_n_fn);
+            }
+            PersistentVector value = (PersistentVector)first_n_fn.invoke(n, target);
+            RubyClass clazz = (RubyClass) context.getRuntime().getClassFromPath("Diametric::Persistence::Collection");
+            DiametricCollection ruby_collection = (DiametricCollection)clazz.allocate();
+            ruby_collection.init(value);
+            return ruby_collection;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+    
+    IRubyObject hash(ThreadContext context, Object target) {
+        try {
+            Var var = DiametricService.getFn("clojure.core", "hash");
+            Integer hash_value = (Integer)var.invoke(target);
+            return context.getRuntime().newFixnum(hash_value);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    IRubyObject to_s(ThreadContext context, Object target) {
+        try {
+            Var to_s_fn = null;
+            if (DiametricService.fnMap.containsKey("to-s")) {
+                to_s_fn = DiametricService.fnMap.get("to-s");
+            } else {
+                Var var = DiametricService.getFn("clojure.core", "load-string");
+                String fn = "(defn to-s [coll] (str (reduce str \"[\" (interpose \", \" coll)) \"]\"))";
+                to_s_fn = (Var)var.invoke(fn);
+                DiametricService.fnMap.put("to-s", to_s_fn);
+            }
+            return context.getRuntime().newString((String)to_s_fn.invoke(target));
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+}

data/ext/diametric/DiametricDatabase.java

@@ -43,10 +43,17 @@ public class DiametricDatabase extends RubyObject {
     
     @JRubyMethod
     public IRubyObject entity(ThreadContext context, IRubyObject arg) {
-        if (!(arg instanceof RubyFixnum)) {
-            throw context.getRuntime().newArgumentError("Argument should be Fixnum");
+        Long entityId = null;
+        if (arg instanceof RubyFixnum) {
+            entityId = (Long) arg.toJava(Long.class);
+        } else if (arg instanceof DiametricObject) {
+            if (((DiametricObject)arg).toJava() instanceof Long) {
+                entityId = (Long)((DiametricObject)arg).toJava();
+            }
+        }
+        if (entityId == null) {
+            throw context.getRuntime().newArgumentError("Argument should be Fixnum or dbid object");
         }
-        Long entityId = (Long) arg.toJava(Long.class);
         try {
             Entity entity = (Entity) clojure.lang.RT.var("datomic.api", "entity").invoke(database, entityId);
             RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Entity");

data/ext/diametric/DiametricPeer.java

@@ -261,10 +261,6 @@ public class DiametricPeer extends RubyModule {
                     for (int i=0; i<inputs.length; i++) {
                         inputs[i] = DiametricUtils.convertRubyToJava(context, ruby_inputs.shift(context));
                     }
-                    //System.out.println("OH INPUTS ARE: ");
-                    //for (int i=0; i<inputs.length; i++) {
-                    //    System.out.println("OH: " + inputs[i]);
-                    //}
                     results = (Collection<List<Object>>) clojure.lang.RT.var("datomic.api", "q").invoke(query, database, inputs);
                 }
             } else {
@@ -279,6 +275,11 @@ public class DiametricPeer extends RubyModule {
         }
 
         if (results == null) return context.getRuntime().getNil();
+        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Set");
+        DiametricSet diametric_set = (DiametricSet)clazz.allocate();
+        diametric_set.init(results);
+        return diametric_set;
+        /*
         RubyArray ruby_results = RubyArray.newArray(context.getRuntime());
         for (List list : results) {
             RubyArray ruby_elements = RubyArray.newArray(context.getRuntime());
@@ -289,6 +290,7 @@ public class DiametricPeer extends RubyModule {
             ruby_results.append(ruby_elements);
         }
         return ruby_results;
+        */
     }
     
     private static List<RubyModule> bases = new ArrayList<RubyModule>();
@@ -411,4 +413,10 @@ public class DiametricPeer extends RubyModule {
             throw runtime.newArgumentError("Arguments should be 'database, dbid, query_string'");
         }
     }
+
+    @JRubyMethod(meta=true)
+    public static IRubyObject get_set(ThreadContext context, IRubyObject klazz) {
+        IRubyObject set = context.getRuntime().getClass("Set");
+        return context.getRuntime().getNil();
+    }
 }

data/ext/diametric/DiametricService.java

@@ -1,6 +1,9 @@
 package diametric;
 
 import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
@@ -9,6 +12,9 @@ import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.load.BasicLibraryService;
 
+import clojure.lang.RT;
+import clojure.lang.Var;
+
 public class DiametricService implements BasicLibraryService {
 
     @Override
@@ -28,8 +34,11 @@ public class DiametricService implements BasicLibraryService {
         RubyClass diametric_object = persistence.defineClassUnder("Object", runtime.getObject(), DIAMETRIC_OBJECT_ALLOCATOR);
         diametric_object.defineAnnotatedMethods(DiametricObject.class);
 
-        RubyClass diametric_query_result = persistence.defineClassUnder("Collection", runtime.getObject(), COLLECTION_ALLOCATOR);
-        diametric_query_result.defineAnnotatedMethods(DiametricCollection.class);
+        RubyClass diametric_collection = persistence.defineClassUnder("Collection", runtime.getObject(), COLLECTION_ALLOCATOR);
+        diametric_collection.defineAnnotatedMethods(DiametricCollection.class);
+
+        RubyClass diametric_set = persistence.defineClassUnder("Set", runtime.getObject(), SET_ALLOCATOR);
+        diametric_set.defineAnnotatedMethods(DiametricSet.class);
 
         RubyClass diametric_listenable = persistence.defineClassUnder("ListenableFuture", runtime.getObject(), LISTENABLE_ALLOCATOR);
         diametric_listenable.defineAnnotatedMethods(DiametricListenableFuture.class);
@@ -78,6 +87,12 @@ public class DiametricService implements BasicLibraryService {
         }
     };
 
+    public static final ObjectAllocator SET_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricSet(runtime, klazz);
+        }
+    };
+
     public static final ObjectAllocator LISTENABLE_ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
             return new DiametricListenableFuture(runtime, klazz);
@@ -96,7 +111,25 @@ public class DiametricService implements BasicLibraryService {
         }
     };
 
+    static Map<String, Var> fnMap = null;
+
     private void setupClojureRT() {
         clojure.lang.RT.var("clojure.core", "require").invoke(clojure.lang.Symbol.intern("datomic.api"));
+        clojure.lang.RT.var("clojure.core", "require").invoke(clojure.lang.Symbol.intern("clojure.string"));
+        if (fnMap == null) {
+            fnMap = new HashMap<String, Var>();
+            Collections.synchronizedMap(fnMap);
+        }
+    }
+
+    static Var getFn(String namespace, String fn) {
+        String fullname = namespace + "/" + fn;
+        if (fnMap.containsKey(fullname)) {
+            return fnMap.get(fullname);
+        } else {
+            Var var = RT.var(namespace, fn);
+            fnMap.put(fullname, var);
+            return var;
+        }
     }
 }

data/ext/diametric/DiametricSet.java

@@ -0,0 +1,270 @@
+package diametric;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import clojure.lang.IPersistentSet;
+import clojure.lang.PersistentHashMap;
+import clojure.lang.PersistentHashSet;
+import clojure.lang.Var;
+
+@JRubyClass(name = "Diametric::Persistence::Set")
+public class DiametricSet extends RubyObject {
+    private static final long serialVersionUID = 2565282201531713809L;
+    private Set<Object> set = null; // java.util.HashSet or clojure.lang.PersistentHashSet
+    private Integer count = null;  // unable to count the vector size that exceeds Integer
+    private DiametricCommon common = null;
+
+    public DiametricSet(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz);
+    }
+
+    void init(Object value) {
+        if ((value instanceof PersistentHashSet) || (value instanceof HashSet)) {
+            set = (Set)value;
+        } else if (value instanceof List) {
+            set = (Set)PersistentHashSet.create((List)value);
+        } else {
+            throw new RuntimeException("Wrong type for Set");
+        }
+        common = new DiametricCommon();
+    }
+
+    PersistentHashSet convertHashSetToPersistentHashSet(Set set) {
+        // bad performance conversion, needs to be careful to use
+        return PersistentHashSet.create(set.toArray(new Object[0]));
+    }
+
+    Object toJava() {
+        return set;
+    }
+
+    @JRubyMethod(meta=true)
+    public static IRubyObject wrap(ThreadContext context, IRubyObject klazz, IRubyObject arg) {
+        try {
+            Set<Object> s = (Set<Object>)arg.toJava(Set.class);
+            RubyClass clazz = (RubyClass) context.getRuntime().getClassFromPath("Diametric::Persistence::Set");
+            DiametricSet ruby_set = (DiametricSet)clazz.allocate();
+            ruby_set.init(s);
+            return ruby_set;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject to_java(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), set);
+    }
+
+    @JRubyMethod(name={"collect", "map"})
+    public IRubyObject collect(ThreadContext context, Block block) {
+        if (block.isGiven()) {
+            return common.collect(context, block, set.iterator());
+        }
+        return this;       
+    }
+
+    @JRubyMethod
+    public IRubyObject each(ThreadContext context, Block block) {
+        if (block.isGiven()) {
+            common.each(context, block, set.iterator());
+        }
+        return this;
+    }
+
+    @JRubyMethod(name="empty?")
+    public IRubyObject empty_p(ThreadContext context) {
+        return common.empty_p(context, set);
+    }
+
+    @JRubyMethod(name={"==", "eql?", "equal?"})
+    public IRubyObject equal_p(ThreadContext context, IRubyObject arg) {
+        if (arg.isNil()) return context.getRuntime().getFalse();
+        IPersistentSet other = null;
+        if (arg.respondsTo("intersection")) {
+            other = DiametricUtils.getPersistentSet(context, arg);
+        } else if (arg instanceof HashSet) {
+            other = convertHashSetToPersistentHashSet((HashSet)arg);
+        } else if (arg instanceof DiametricSet) {
+            if (((DiametricSet)arg).toJava() instanceof HashSet) {
+                other = convertHashSetToPersistentHashSet((HashSet)((DiametricSet)arg).toJava());
+            } else {
+                other = (IPersistentSet)((DiametricSet)arg).toJava();
+            }
+        } else {
+            return context.getRuntime().getFalse();
+        }
+        try {
+            Var var = DiametricService.getFn("clojure.core", "=");
+            if ((Boolean)var.invoke(set, other)) {
+                return context.getRuntime().getTrue();
+            } else {
+                return context.getRuntime().getFalse();
+            }
+        } catch(Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod(name={"drop", "take"})
+    public IRubyObject drop(ThreadContext context, IRubyObject arg) {
+        if (!(arg instanceof RubyFixnum)) {
+            throw context.getRuntime().newArgumentError("argument should be Fixnum");
+        }
+        Long n = (Long)arg.toJava(Long.class);
+        if (n < 0) {
+            throw context.getRuntime().newArgumentError("negative drop size");
+        }
+        if (n == 0) return this;
+        return common.drop_or_take(context, n, set);
+    }
+
+    @JRubyMethod
+    public IRubyObject first(ThreadContext context) {
+        Object first = common.first(context, set);
+        return DiametricUtils.convertJavaToRuby(context, first);
+    }
+
+    @JRubyMethod
+    public IRubyObject group_by(ThreadContext context, Block block) {
+        Ruby runtime = context.getRuntime();
+        if (block.isGiven()) {
+            RubyHash hash_result = new RubyHash(runtime);
+            Iterator<Object> itr = set.iterator();
+            while (itr.hasNext()) {
+                IRubyObject ruby_next = DiametricUtils.convertJavaToRuby(context, itr.next());
+                IRubyObject block_result = block.yield(context, ruby_next);
+                IRubyObject value = hash_result.callMethod(context, "[]", block_result);
+                if (value.isNil()) {
+                    // new key
+                    IRubyObject[] args = new IRubyObject[]{block_result, runtime.newArray()};
+                    value = hash_result.callMethod(context, "[]=", args);
+                }
+                value.callMethod(context, "<<", ruby_next);
+            }
+            return hash_result;
+        } else {
+            return this;
+        }
+    }
+
+    @JRubyMethod(name="include?")
+    public IRubyObject include_p(ThreadContext context, IRubyObject arg) {
+        Object java_object = DiametricUtils.convertRubyToJava(context, arg);
+        try {
+            Var var = DiametricService.getFn("clojure.core", "contains?");
+            if ((Boolean)var.invoke(set, java_object)) {
+                return context.getRuntime().getTrue();
+            } else {
+                return context.getRuntime().getFalse();
+            }
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod(name={"&", "intersection"})
+    public IRubyObject intersection(ThreadContext context, IRubyObject arg) {
+        if (!(arg.respondsTo("intersection"))) throw context.getRuntime().newArgumentError("argument should be a set");
+        IPersistentSet other = (IPersistentSet)DiametricUtils.getPersistentSet(context, arg);
+        try {
+            Var var = DiametricService.getFn("clojure.set", "intersection");
+            if (set instanceof HashSet) {
+                PersistentHashSet value = convertHashSetToPersistentHashSet(set);
+                return DiametricUtils.convertJavaToRuby(context, var.invoke(value, other));
+            } else {
+                return DiametricUtils.convertJavaToRuby(context, var.invoke(set, other));
+            }
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    private int getCount() {
+        if (count == null) {
+            Var var = DiametricService.getFn("clojure.core", "count");
+            count = (Integer)var.invoke(set);
+        }
+        return count;
+    }
+
+    @JRubyMethod(name={"length", "size"})
+    public IRubyObject size(ThreadContext context) {
+        try {
+            return context.getRuntime().newFixnum(getCount());
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject to_a(ThreadContext context) {
+        try {
+            RubyArray array = context.getRuntime().newArray();
+            Iterator<Object> itr = set.iterator();
+            while (itr.hasNext()) {
+                Object value = itr.next();
+                array.callMethod(context, "<<", DiametricUtils.convertJavaToRuby(context, value));
+            }
+            return array;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject to_s(ThreadContext context) {
+        return common.to_s(context, set);
+    }
+
+    @JRubyMethod(name={"|", "union"})
+    public IRubyObject union(ThreadContext context, IRubyObject arg) {
+        if (!(arg.respondsTo("union"))) throw context.getRuntime().newArgumentError("argument should be a set");
+        IPersistentSet other = (IPersistentSet)DiametricUtils.getPersistentSet(context, arg);
+        try {
+            Var var = DiametricService.getFn("clojure.set", "union");
+            if (set instanceof HashSet) {
+                PersistentHashSet value = convertHashSetToPersistentHashSet(set);
+                return DiametricUtils.getDiametricSet(context, (Set)var.invoke(value, other));
+            } else {
+                return DiametricUtils.getDiametricSet(context, (Set)var.invoke(set, other));
+            }
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod(name={"-", "difference"})
+    public IRubyObject difference(ThreadContext context, IRubyObject arg) {
+        if (!(arg.respondsTo("difference"))) throw context.getRuntime().newArgumentError("argument should be a set");
+        IPersistentSet other = (IPersistentSet)DiametricUtils.getPersistentSet(context, arg);
+        try {
+            Var var = DiametricService.getFn("clojure.set", "difference");
+            if (set instanceof HashSet) {
+                PersistentHashSet value = convertHashSetToPersistentHashSet(set);
+                return DiametricUtils.getDiametricSet(context, (Set)var.invoke(value, other));
+            } else {
+                return DiametricUtils.getDiametricSet(context, (Set)var.invoke(set, other));
+            }
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+}