diametric 0.1.1-java

data/diametric-java.gemspec

@@ -0,0 +1,39 @@
+# -*- ruby -*-
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'diametric/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "diametric"
+  gem.version       = Diametric::VERSION
+  gem.authors       = ["Clinton N. Dreisbach", "Ryan K. Neufeld", "Yoko Harada"]
+  gem.email         = ["crnixon@gmail.com", "ryan@thinkrelevance.com", "yoko@thinkrelevance.com"]
+  gem.summary       = %q{ActiveModel for Datomic (JRuby)}
+  gem.description   = <<EOF
+Diametric is a library for building schemas, queries, and transactions
+for Datomic from Ruby objects. It is also used to map Ruby objects
+as entities into a Datomic database.
+EOF
+  gem.homepage      = "https://github.com/relevance/diametric"
+  gem.platform      = 'java'
+
+  gem.files         = %w(Gemfile Jarfile LICENSE.txt README.md Rakefile datomic_version.yml diametric-java.gemspec) + Dir.glob('lib/**/*') + Dir.glob('ext/**/*') + Dir.glob('spec/**/*')
+  gem.executables   = []
+  gem.test_files    = Dir.glob("spec/**/*.rb")
+  gem.require_paths = ["lib"]
+  gem.executables = ["datomic-rest", "download-datomic"]
+
+  gem.add_dependency 'edn', '~> 1.0.2'
+  gem.add_dependency 'activesupport', '~> 3.2.14'
+  gem.add_dependency 'activemodel', '~> 3.2.14'
+  gem.add_dependency 'datomic-client', '~> 0.4.1'
+  gem.add_dependency 'rubyzip', '~> 0.9.9'
+  gem.add_dependency 'lock_jar', '~> 0.7.5'
+  gem.add_dependency 'jruby-openssl', '~> 0.8.8'
+  gem.add_dependency 'uuid', '~> 2.3.7'
+  gem.add_dependency 'rspec', '~> 2.14.1'
+  gem.add_dependency 'rake-compiler', '~> 0.9.1'
+
+  gem.extensions = ['Rakefile']
+end

data/ext/diametric/DiametricCollection.java

@@ -0,0 +1,147 @@
+package diametric;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+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;
+
+@JRubyClass(name = "Diametric::Persistence::Collection")
+public class DiametricCollection extends RubyObject {
+    // should be a Ruby's Enumerable
+    private static final long serialVersionUID = 7656855654760249694L;
+    private Collection query_result = null;
+
+    public DiametricCollection(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz);
+    }
+    
+    void init(Object result) {
+        if (result instanceof Collection) {
+            this.query_result = (Collection)result;
+        } else {
+            throw new RuntimeException("Wrong type of query result");
+        }
+    }
+
+    Object toJava() {
+        return query_result;
+    }
+
+    @JRubyMethod
+    public IRubyObject to_java(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), query_result);
+    }
+    
+    @JRubyMethod(name="==", required=1)
+    public IRubyObject op_equal(ThreadContext context, IRubyObject arg) {
+        Ruby runtime = context.getRuntime();
+        if (arg instanceof DiametricCollection) {
+            DiametricCollection other = (DiametricCollection)arg;
+            if (query_result.toString().equals(other.toJava().toString())) {
+                return runtime.getTrue();
+            } else {
+                return runtime.getFalse();
+            }
+        } else {
+            return runtime.getFalse();
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject to_s(ThreadContext context) {
+        return context.getRuntime().newString(query_result.toString());
+    }
+    
+    @JRubyMethod(name = "all?")
+    public static IRubyObject all_p(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+
+    @JRubyMethod(name = "any?")
+    public static IRubyObject any_p(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject chunk(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject chunk(ThreadContext context, IRubyObject self, final IRubyObject initialState, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject collect(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject collect_concat(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject count(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject count(ThreadContext context, IRubyObject self, final IRubyObject methodArg, final Block block) {
+        return context.getRuntime().getNil();
+    }
+
+    @JRubyMethod
+    public static IRubyObject cycle(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject cycle(ThreadContext context, IRubyObject self, IRubyObject arg, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject detect(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject detect(ThreadContext context, IRubyObject self, IRubyObject ifnone, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject drop(ThreadContext context, IRubyObject self, IRubyObject n, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject drop_while(ThreadContext context, IRubyObject self, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject each_cons(ThreadContext context, IRubyObject self, IRubyObject arg, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod(rest = true)
+    public static IRubyObject each_entry(ThreadContext context, final IRubyObject self, final IRubyObject[] args, final Block block) {
+        return context.getRuntime().getNil();
+    }
+    
+    @JRubyMethod
+    public static IRubyObject each_slice(ThreadContext context, IRubyObject self, IRubyObject arg, final Block block) {
+        return context.getRuntime().getNil();
+    }
+}

data/ext/diametric/DiametricConnection.java

@@ -0,0 +1,113 @@
+package diametric;
+
+import java.util.Date;
+import java.util.List;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyTime;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+@JRubyClass(name = "Diametric::Persistence::Connection")
+public class DiametricConnection extends RubyObject {
+    private static final long serialVersionUID = 3806301567154638371L;
+    //conn should a datomic.Connection type
+    private Object conn = null;
+
+    public DiametricConnection(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz);
+    }
+
+    void init(Object conn) {
+        this.conn = conn;
+    }
+
+    Object toJava() {
+        return conn;
+    }
+
+    @JRubyMethod
+    public IRubyObject to_java(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), conn);
+    }
+
+    @JRubyMethod
+    public IRubyObject db(ThreadContext context) {
+        try {
+            Object database = clojure.lang.RT.var("datomic.api", "db").invoke(conn);
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Database");
+            DiametricDatabase diametric_database = (DiametricDatabase)clazz.allocate();
+            diametric_database.init(database);
+            return diametric_database;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject transact(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 {
+            Object future = clojure.lang.RT.var("datomic.api", "transact").invoke(conn, tx_data);
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::ListenableFuture");
+            DiametricListenableFuture diametric_listenable = (DiametricListenableFuture)clazz.allocate();
+            diametric_listenable.init(future);
+            return diametric_listenable;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject transact_async(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 {
+            Object future = clojure.lang.RT.var("datomic.api", "transact-async").invoke(conn, tx_data);
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::ListenableFuture");
+            DiametricListenableFuture diametric_listenable = (DiametricListenableFuture)clazz.allocate();
+            diametric_listenable.init(future);
+            return diametric_listenable;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject gc_storage(ThreadContext context, IRubyObject arg) {
+        if (!(arg.respondsTo("to_time"))) {
+            throw context.getRuntime().newArgumentError("Wrong argument type");
+        }
+        RubyTime rubyTime = (RubyTime) RuntimeHelpers.invoke(context, arg, "to_time");
+        Date olderThan = rubyTime.getJavaDate();
+        try {
+            clojure.lang.RT.var("datomic.api", "gc-strage").invoke(conn, olderThan);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError("Datomic error: " + t.getMessage());
+        }
+        return context.getRuntime().getNil();
+    }
+
+    @JRubyMethod
+    public IRubyObject release(ThreadContext context) {
+        try {
+            clojure.lang.RT.var("datomic.api", "release").invoke(conn);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+        return context.getRuntime().getNil();
+    }
+}

data/ext/diametric/DiametricDatabase.java

@@ -0,0 +1,107 @@
+package diametric;
+
+import java.util.List;
+import java.util.Map;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import datomic.Database;
+import datomic.Entity;
+
+@JRubyClass(name = "Diametric::Persistence::Database")
+public class DiametricDatabase extends RubyObject {
+    private static final long serialVersionUID = 6043433195693171937L;
+    // database supposed to be datomic.Database type
+    private Object database = null;
+
+    public DiametricDatabase(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz);
+    }
+    
+    void init(Object database) {
+        this.database = database;
+    }
+    
+    Object toJava() {
+        return database;
+    }
+    
+    @JRubyMethod
+    public IRubyObject to_java(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), database);
+    }
+    
+    @JRubyMethod
+    public IRubyObject entity(ThreadContext context, IRubyObject arg) {
+        if (!(arg instanceof RubyFixnum)) {
+            throw context.getRuntime().newArgumentError("Argument should be Fixnum");
+        }
+        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");
+            DiametricEntity diametric_entity = (DiametricEntity)clazz.allocate();
+            diametric_entity.init(entity);
+            return diametric_entity;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError("Datomic Error: " + t.getMessage());
+        }
+    }
+    
+    @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);
+            return RubyHash.newHash(context.getRuntime(), map, null);
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError("Datomic Error: " + t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    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);
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Database");
+            DiametricDatabase diametric_database = (DiametricDatabase)clazz.allocate();
+            diametric_database.init(db_asof_t);
+            return diametric_database;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError("Datomic Error: " + t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    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);
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Database");
+            DiametricDatabase diametric_database = (DiametricDatabase)clazz.allocate();
+            diametric_database.init(db_since_t);
+            return diametric_database;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError("Datomic Error: " + t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject id(ThreadContext context) {
+        return RubyString.newString(context.getRuntime(), ((Database)database).id());
+    }
+}

data/ext/diametric/DiametricEntity.java

@@ -0,0 +1,90 @@
+package diametric;
+
+import java.util.Collection;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+@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;
+
+    public DiametricEntity(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz);
+    }
+    
+    void init(Object entity) {
+        this.entity = entity;
+    }
+    
+    Object toJava() {
+        return entity;
+    }
+    
+    @JRubyMethod
+    public IRubyObject to_java(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), entity);
+    }
+    
+    @JRubyMethod
+    public IRubyObject db(ThreadContext context) {
+        try {
+            Object database = clojure.lang.RT.var("datomic.api", "db").invoke(entity);
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Database");
+            DiametricDatabase diametric_database = (DiametricDatabase)clazz.allocate();
+            diametric_database.init(database);
+            return diametric_database;
+        } 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);
+        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);
+            entity = touched_entity;
+            return this;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject eid(ThreadContext context) {
+        if (entity instanceof datomic.query.EntityMap) {
+            Long eid = (Long) ((datomic.query.EntityMap)entity).eid;
+            return RubyFixnum.newFixnum(context.getRuntime(), eid);
+        }
+        return context.getRuntime().getNil();
+    }
+}