diametric 0.1.2-java → 0.1.3-java

data/ext/diametric/DiametricDatabase.java

@@ -55,7 +55,7 @@ public class DiametricDatabase extends RubyObject {
             throw context.getRuntime().newArgumentError("Argument should be Fixnum or dbid object");
         }
         try {
-            Entity entity = (Entity) clojure.lang.RT.var("datomic.api", "entity").invoke(database, entityId);
+            Entity entity = (Entity) DiametricService.getFn("datomic.api", "entity").invoke(database, entityId);
             RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Entity");
             DiametricEntity diametric_entity = (DiametricEntity)clazz.allocate();
             diametric_entity.init(entity);
@@ -67,12 +67,13 @@ public class DiametricDatabase extends RubyObject {
     
     @JRubyMethod
     public IRubyObject with(ThreadContext context, IRubyObject arg) {
-        List<Object> tx_data = DiametricUtils.convertRubyTxDataToJava(context, arg);
-        if (tx_data == null) {
-            throw context.getRuntime().newArgumentError("Argument should be Array or clojure.lang.PersistentVector");
-        }
         try {
-            Map map = (Map) clojure.lang.RT.var("datomic.api", "with").invoke(database, tx_data);
+            List<Object> tx_data = DiametricUtils.convertRubyTxDataToJava(context, arg); // may raise exception
+            if (tx_data == null) {
+                throw context.getRuntime().newArgumentError("Argument should be Array or clojure.lang.PersistentVector");
+            }
+
+            Map map = (Map) DiametricService.getFn("datomic.api", "with").invoke(database, tx_data);
             return RubyHash.newHash(context.getRuntime(), map, null);
         } catch (Throwable t) {
             throw context.getRuntime().newRuntimeError("Datomic Error: " + t.getMessage());
@@ -83,7 +84,7 @@ public class DiametricDatabase extends RubyObject {
     public IRubyObject as_of(ThreadContext context, IRubyObject arg) {
         Object t_value = DiametricUtils.convertRubyToJava(context, arg);
         try {
-            Database db_asof_t = (Database) clojure.lang.RT.var("datomic.api", "as-of").invoke(database, t_value);
+            Database db_asof_t = (Database) DiametricService.getFn("datomic.api", "as-of").invoke(database, t_value);
             RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Database");
             DiametricDatabase diametric_database = (DiametricDatabase)clazz.allocate();
             diametric_database.init(db_asof_t);
@@ -97,7 +98,7 @@ public class DiametricDatabase extends RubyObject {
     public IRubyObject since(ThreadContext context, IRubyObject arg) {
         Object t_value = DiametricUtils.convertRubyToJava(context, arg);
         try {
-            Database db_since_t = (Database) clojure.lang.RT.var("datomic.api", "since").invoke(database, t_value);
+            Database db_since_t = (Database) DiametricService.getFn("datomic.api", "since").invoke(database, t_value);
             RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Database");
             DiametricDatabase diametric_database = (DiametricDatabase)clazz.allocate();
             diametric_database.init(db_since_t);

data/ext/diametric/DiametricEntity.java

@@ -1,6 +1,8 @@
 package diametric;
 
 import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
@@ -14,12 +16,21 @@ import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
+import clojure.lang.Var;
+
 @JRubyClass(name = "Diametric::Persistence::Entity")
 public class DiametricEntity extends RubyObject {
     private static final long serialVersionUID = 3906852174830144427L;
     //entity should be datomic.Entity type
     private Object entity = null;
 
+    static IRubyObject getDiametricEntity(ThreadContext context, Object value) {
+        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Entity");
+        DiametricEntity diametric_entity = (DiametricEntity)clazz.allocate();
+        diametric_entity.init(value);
+        return diametric_entity;
+    }
+
     public DiametricEntity(Ruby runtime, RubyClass klazz) {
         super(runtime, klazz);
     }
@@ -40,7 +51,7 @@ public class DiametricEntity extends RubyObject {
     @JRubyMethod
     public IRubyObject db(ThreadContext context) {
         try {
-            Object database = clojure.lang.RT.var("datomic.api", "db").invoke(entity);
+            Object database = DiametricService.getFn("datomic.api", "db").invoke(entity);
             RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Database");
             DiametricDatabase diametric_database = (DiametricDatabase)clazz.allocate();
             diametric_database.init(database);
@@ -49,29 +60,11 @@ public class DiametricEntity extends RubyObject {
             throw context.getRuntime().newRuntimeError(t.getMessage());
         }
     }
-    
-    @JRubyMethod(name={"[]","get"}, required=1)
-    public IRubyObject op_aref(ThreadContext context, IRubyObject arg) {
-        String key = (String) arg.toJava(String.class);
-        Object value = clojure.lang.RT.var("clojure.core", "get").invoke(entity, key);
-        return DiametricUtils.convertJavaToRuby(context, value);
-    }
-    
-    @JRubyMethod
-    public IRubyObject keys(ThreadContext context) {
-        Collection keys = (Collection) clojure.lang.RT.var("clojure.core", "keys").invoke(entity);
-        RubyArray ruby_keys = RubyArray.newArray(context.getRuntime());
-        for (Object key : keys) {
-            // keys are clojure.lang.Keyword
-            ruby_keys.append(RubyString.newString(context.getRuntime(), key.toString()));
-        }
-        return ruby_keys;
-    }
-    
+
     @JRubyMethod
     public IRubyObject touch(ThreadContext context) {
         try {
-            Object touched_entity = clojure.lang.RT.var("datomic.api", "touch").invoke(entity);
+            Object touched_entity = DiametricService.getFn("datomic.api", "touch").invoke(entity);
             entity = touched_entity;
             return this;
         } catch (Throwable t) {
@@ -87,4 +80,94 @@ public class DiametricEntity extends RubyObject {
         }
         return context.getRuntime().getNil();
     }
+
+    @JRubyMethod(name={"==","eql?"}, required=1)
+    public IRubyObject eql_p(ThreadContext context, IRubyObject arg) {
+        Object other = DiametricUtils.convertRubyToJava(context, arg);
+        try {
+            Var var = DiametricService.getFn("clojure.core", "=");
+            Boolean value = (Boolean)var.invoke(entity, other);
+            return context.getRuntime().newBoolean(value);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod(name={"[]","get"}, required=1)
+    public IRubyObject op_aref(ThreadContext context, IRubyObject arg) {
+        String key = (String) arg.toJava(String.class);
+        try {
+            Var var = DiametricService.getFn("clojure.core", "get");
+            Object value = var.invoke(entity, key);
+            return DiametricUtils.convertJavaToRuby(context, value);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod(name={"has_key?","include?", "key?", "member?"}, required=1)
+    public IRubyObject has_key_p(ThreadContext context, IRubyObject arg) {
+        String key = (String) arg.toJava(String.class);
+        try {
+            Var var = DiametricService.getFn("clojure.core", "contains?");
+            Boolean value = (Boolean)var.invoke(entity, key);
+            return context.getRuntime().newBoolean(value);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject keys(ThreadContext context) {
+        try {
+            Var var = DiametricService.getFn("clojure.core", "keys");
+            List<Object> keys = (List<Object>) var.invoke(entity);
+            RubyArray ruby_keys = RubyArray.newArray(context.getRuntime());
+            for (Object key : keys) {
+                // keys are clojure.lang.Keyword
+                ruby_keys.append(RubyString.newString(context.getRuntime(), key.toString()));
+            }
+            return ruby_keys;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject values(ThreadContext context) {
+        try {
+            Var var = DiametricService.getFn("clojure.core", "vals");
+            List<Object> keys = (List<Object>) var.invoke(entity);
+            RubyArray ruby_keys = RubyArray.newArray(context.getRuntime());
+            for (Object key : keys) {
+                // keys are clojure.lang.Keyword
+                ruby_keys.append(RubyString.newString(context.getRuntime(), key.toString()));
+            }
+            return ruby_keys;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod(name={"length", "size"})
+    public IRubyObject length(ThreadContext context) {
+        try {
+            Var var = DiametricService.getFn("clojure.core", "count");
+            Integer count = (Integer) var.invoke(entity);
+            return context.getRuntime().newFixnum(count);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject to_s(ThreadContext context) {
+        try {
+            Var var = DiametricService.getFn("clojure.core", "str");
+            String str = (String) var.invoke(entity);
+            return context.getRuntime().newString(str);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
 }

data/ext/diametric/DiametricObject.java

@@ -59,8 +59,19 @@ public class DiametricObject extends RubyObject {
         }
     }
 
-    @JRubyMethod
+    @JRubyMethod(name={"to_s", "to_edn"})
     public IRubyObject to_s(ThreadContext context) {
+        if (java_object == null) {
+            return context.getRuntime().getNil();
+        }
         return context.getRuntime().newString(java_object.toString());
     }
+
+    @JRubyMethod
+    public IRubyObject to_i(ThreadContext context) {
+        if (java_object instanceof Long) {
+            return context.getRuntime().newFixnum((Long)java_object);
+        }
+        return context.getRuntime().getNil();
+    }
 }

data/ext/diametric/DiametricPeer.java

@@ -18,11 +18,14 @@ import org.jruby.RubyString;
 import org.jruby.RubySymbol;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.anno.JRubyModule;
+import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
+import clojure.lang.Keyword;
 import clojure.lang.PersistentHashSet;
+import clojure.lang.PersistentVector;
 import datomic.Connection;
 import datomic.Peer;
 
@@ -55,20 +58,26 @@ public class DiametricPeer extends RubyModule {
         DiametricConnection rubyConnection = (DiametricConnection)clazz.allocate();
         try {
             // what value will be returned when connect fails? API doc doesn't tell anything.
-            Connection connection = (Connection) clojure.lang.RT.var("datomic.api", "connect").invoke(uriOrMap);
+            Connection connection = (Connection) DiametricService.getFn("datomic.api", "connect").invoke(uriOrMap);
             rubyConnection.init(connection);
             saved_connection = rubyConnection;
             return rubyConnection;
         } catch (Exception e) {
             // Diametric doesn't require creating database before connect.
-            if (e.getMessage().contains(":peer/db-not-found") && (Boolean)clojure.lang.RT.var("datomic.api", "create-database").invoke(uriOrMap)) {
-                Connection connection = (Connection) clojure.lang.RT.var("datomic.api", "connect").invoke(uriOrMap);
-                rubyConnection.init(connection);
-                saved_connection = rubyConnection;
-                return rubyConnection;
+            // if database has not yet created, try that first and return the connection
+            if (e instanceof clojure.lang.ExceptionInfo) {
+                try {
+                    DiametricService.getFn("datomic.api", "create-database").invoke(uriOrMap);
+                    Connection connection = (Connection) DiametricService.getFn("datomic.api", "connect").invoke(uriOrMap);
+                    rubyConnection.init(connection);
+                    saved_connection = rubyConnection;
+                    return rubyConnection;
+                } catch (Throwable t) {
+                    throw context.getRuntime().newRuntimeError(t.getMessage());
+                }
             }
+            throw context.getRuntime().newRuntimeError(e.getMessage());
         }
-        throw context.getRuntime().newRuntimeError("Failed to create connection");
     }
     
     @JRubyMethod(meta=true)
@@ -77,7 +86,7 @@ public class DiametricPeer extends RubyModule {
         if (uriOrMap == null)
             throw context.getRuntime().newArgumentError("Argument should be a String");
         try {
-            boolean status = (Boolean)clojure.lang.RT.var("datomic.api", "create-database").invoke(uriOrMap);
+            boolean status = (Boolean)DiametricService.getFn("datomic.api", "create-database").invoke(uriOrMap);
             return RubyBoolean.newBoolean(context.getRuntime(), status);
         } catch (Exception e) {
             throw context.getRuntime().newRuntimeError("Datomic Error: " + e.getMessage());
@@ -92,7 +101,7 @@ public class DiametricPeer extends RubyModule {
         String newName = DiametricUtils.rubyStringToJava(args[1]);
         if (newName == null) return context.getRuntime().getNil();
         try {
-            boolean status = (Boolean)clojure.lang.RT.var("datomic.api", "rename-database").invoke(uriOrMap, newName);
+            boolean status = (Boolean)DiametricService.getFn("datomic.api", "rename-database").invoke(uriOrMap, newName);
             return RubyBoolean.newBoolean(context.getRuntime(), status);
         } catch (Exception e) {
             throw context.getRuntime().newRuntimeError("Datomic Error: " + e.getMessage());
@@ -104,7 +113,7 @@ public class DiametricPeer extends RubyModule {
         String uriOrMap = DiametricUtils.rubyStringToJava(arg);
         if (uriOrMap == null) return context.getRuntime().getNil();
         try {
-            boolean status = (Boolean)clojure.lang.RT.var("datomic.api", "delete-database").invoke(uriOrMap);
+            boolean status = (Boolean)DiametricService.getFn("datomic.api", "delete-database").invoke(uriOrMap);
             return RubyBoolean.newBoolean(context.getRuntime(), status);
         } catch (Exception e) {
             throw context.getRuntime().newRuntimeError("Datomic Error: " + e.getMessage());
@@ -118,7 +127,7 @@ public class DiametricPeer extends RubyModule {
         }
         Boolean shutdownClojure = (Boolean) arg.toJava(Boolean.class);
         try {
-            clojure.lang.RT.var("datomic.api", "shutdown").invoke(shutdownClojure);
+            DiametricService.getFn("datomic.api", "shutdown").invoke(shutdownClojure);
         } catch (Exception e) {
             throw context.getRuntime().newRuntimeError("Datomic Error: " + e.getMessage());
         }
@@ -137,7 +146,7 @@ public class DiametricPeer extends RubyModule {
         RubyClass clazz = (RubyClass) context.getRuntime().getClassFromPath("Diametric::Persistence::UUID");
         diametric.DiametricUUID ruby_uuid = (diametric.DiametricUUID)clazz.allocate();
         try {
-            java.util.UUID java_uuid = (UUID) clojure.lang.RT.var("datomic.api", "squuid").invoke();
+            java.util.UUID java_uuid = (UUID) DiametricService.getFn("datomic.api", "squuid").invoke();
             ruby_uuid.init(java_uuid);
             return ruby_uuid;
         } catch (Throwable t) {
@@ -162,7 +171,7 @@ public class DiametricPeer extends RubyModule {
         if (squuid == null) return context.getRuntime().getNil();
         long value;
         try {
-            value = (Long) clojure.lang.RT.var("datomic.api", "squuid-time-millis").invoke(squuid);
+            value = (Long) DiametricService.getFn("datomic.api", "squuid-time-millis").invoke(squuid);
             return RubyFixnum.newFixnum(context.getRuntime(), value);
         } catch (Throwable t) {
             throw context.getRuntime().newRuntimeError("Datomic Exception: " + t.getMessage());
@@ -184,11 +193,15 @@ public class DiametricPeer extends RubyModule {
         if (args.length < 1 || args.length > 2) {
             throw context.getRuntime().newArgumentError("Wrong number of arguments");
         }
-        String partition = DiametricUtils.rubyStringToJava(args[0]);
+        if (!(args[0] instanceof RubySymbol)) {
+            throw context.getRuntime().newArgumentError("The first argument should be a Symbol");
+        }
+        RubyString edn_string = (RubyString)RuntimeHelpers.invoke(context, args[0], "to_s");
+        Keyword partition = Keyword.intern((String)edn_string.asJavaString());
         RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Object");
         DiametricObject diametric_object = (DiametricObject)clazz.allocate();
         try {
-            clojure.lang.Var clj_var = clojure.lang.RT.var("datomic.api", "tempid");
+            clojure.lang.Var clj_var = DiametricService.getFn("datomic.api", "tempid");
             if (args.length > 1 && (args[1] instanceof RubyFixnum)) {
                 long idNumber = (Long) args[1].toJava(Long.class);
                 diametric_object.update(clj_var.invoke(partition, idNumber));
@@ -224,7 +237,7 @@ public class DiametricPeer extends RubyModule {
             throw context.getRuntime().newArgumentError("Wrong argument type.");
         }
         try {
-            Object dbid = clojure.lang.RT.var("datomic.api", "resolve-tempid")
+            Object dbid = DiametricService.getFn("datomic.api", "resolve-tempid")
                             .invoke(map.get(Connection.DB_AFTER), map.get(Connection.TEMPIDS), ruby_object.toJava());
             ruby_object.update(dbid);
             return ruby_object;
@@ -239,36 +252,44 @@ public class DiametricPeer extends RubyModule {
         if (args.length < 2) {
             throw runtime.newArgumentError("Wrong number of arguments");
         }
-        if (!(args[0] instanceof RubyString)) {
-            throw runtime.newArgumentError("The first arg should be a query string");
+        Object query = null;
+        if (args[0] instanceof RubyArray) {
+            try {
+                query = DiametricUtils.fromRubyArray(context, (RubyArray)args[0]);
+            } catch (Throwable t) {
+                throw runtime.newRuntimeError(t.getMessage());
+            }
+        } else if (args[0] instanceof RubyString) {
+            query = DiametricUtils.rubyStringToJava(args[0]);
+        }
+        if (query == null) {
+            throw runtime.newArgumentError("The first arg should be a query string or array");
         }
+        //System.out.println("query: " + query.toString());
         if (!(args[1] instanceof DiametricDatabase)) {
             throw runtime.newArgumentError("The second arg should be a database.");
         }
-        String query = (String)args[0].toJava(String.class);
         Object database = ((DiametricDatabase)args[1]).toJava();
 
         Collection<List<Object>> results = null;
         try {
             if (args.length == 2) {
-                results = (Collection<List<Object>>) clojure.lang.RT.var("datomic.api", "q").invoke(query, database);
+                results = (Collection<List<Object>>) DiametricService.getFn("datomic.api", "q").invoke(query, database);
             } else if ((args.length == 3) && (args[2] instanceof RubyArray)) {
                 RubyArray ruby_inputs = (RubyArray)args[2];
                 if (ruby_inputs.getLength() == 0) {
                     results = Peer.q(query, database);
                 } else {
-                    Object[] inputs = new Object[ruby_inputs.getLength()];
-                    for (int i=0; i<inputs.length; i++) {
-                        inputs[i] = DiametricUtils.convertRubyToJava(context, ruby_inputs.shift(context));
-                    }
-                    results = (Collection<List<Object>>) clojure.lang.RT.var("datomic.api", "q").invoke(query, database, inputs);
+                    PersistentVector clj_args = DiametricUtils.fromRubyArray(context, (RubyArray)ruby_inputs);
+                    //System.out.println("query args: " + clj_args.toString());
+                    results = (Collection<List<Object>>) DiametricService.getFn("datomic.api", "q").invoke(query, database, clj_args);
                 }
             } else {
                 Object[] inputs = new Object[args.length-2];
                 for (int i=0; i<inputs.length; i++) {
                     inputs[i] = DiametricUtils.convertRubyToJava(context, args[i+2]);
                 }
-                results = (Collection<List<Object>>) clojure.lang.RT.var("datomic.api", "q").invoke(query, database, inputs);
+                results = (Collection<List<Object>>) DiametricService.getFn("datomic.api", "q").invoke(query, database, inputs);
             }
         } catch (Throwable t) {
             throw runtime.newRuntimeError("Datomic Exception: " + t.getMessage());
@@ -348,8 +369,8 @@ public class DiametricPeer extends RubyModule {
         }
         if (saved_connection == null) throw runtime.newRuntimeError("Connection is not established");
         try {
-            Object database = clojure.lang.RT.var("datomic.api", "db").invoke(saved_connection.toJava());
-            Object entity = clojure.lang.RT.var("datomic.api", "entity").invoke(database, dbid);
+            Object database = DiametricService.getFn("datomic.api", "db").invoke(saved_connection.toJava());
+            Object entity = DiametricService.getFn("datomic.api", "entity").invoke(database, dbid);
             RubyClass clazz = (RubyClass) context.getRuntime().getClassFromPath("Diametric::Persistence::Entity");
             DiametricEntity ruby_entity = (DiametricEntity)clazz.allocate();
             ruby_entity.init(entity);
@@ -364,7 +385,7 @@ public class DiametricPeer extends RubyModule {
         Object dbid = DiametricUtils.convertRubyToJava(context, arg);
         List query = datomic.Util.list((datomic.Util.list(":db.fn/retractEntity", dbid)));
         try {
-            clojure.lang.RT.var("datomic.api", "transact-async").invoke(saved_connection.toJava(), query);
+            DiametricService.getFn("datomic.api", "transact-async").invoke(saved_connection.toJava(), query);
         } catch (Throwable t) {
             throw context.getRuntime().newRuntimeError("Datomic error: " + t.getMessage());
         }
@@ -388,9 +409,9 @@ public class DiametricPeer extends RubyModule {
             Long dbid = (Long)DiametricUtils.convertRubyToJava(context, args[1]);
             String query_string = (String)args[2].toJava(String.class);
             try {
-                Object entity = clojure.lang.RT.var("datomic.api", "entity").invoke(database, dbid);
+                Object entity = DiametricService.getFn("datomic.api", "entity").invoke(database, dbid);
                 clojure.lang.PersistentHashSet set =
-                         (PersistentHashSet) clojure.lang.RT.var("clojure.core", "get").invoke(entity, query_string);
+                         (PersistentHashSet) DiametricService.getFn("clojure.core", "get").invoke(entity, query_string);
 
                 if (set == null) {
                     return RubyArray.newEmptyArray(runtime);

data/ext/diametric/DiametricService.java

@@ -36,9 +36,11 @@ public class DiametricService implements BasicLibraryService {
 
         RubyClass diametric_collection = persistence.defineClassUnder("Collection", runtime.getObject(), COLLECTION_ALLOCATOR);
         diametric_collection.defineAnnotatedMethods(DiametricCollection.class);
+        diametric_collection.includeModule(runtime.getEnumerable());
 
         RubyClass diametric_set = persistence.defineClassUnder("Set", runtime.getObject(), SET_ALLOCATOR);
         diametric_set.defineAnnotatedMethods(DiametricSet.class);
+        diametric_set.includeModule(runtime.getEnumerable());
 
         RubyClass diametric_listenable = persistence.defineClassUnder("ListenableFuture", runtime.getObject(), LISTENABLE_ALLOCATOR);
         diametric_listenable.defineAnnotatedMethods(DiametricListenableFuture.class);