diametric 0.1.1-java

data/ext/diametric/DiametricService.java

@@ -0,0 +1,102 @@
+package diametric;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class DiametricService implements BasicLibraryService {
+
+    @Override
+    public boolean basicLoad(Ruby runtime) throws IOException {
+        RubyModule diametric = runtime.defineModule("Diametric");
+        RubyModule persistence = diametric.defineModuleUnder("Persistence");
+
+        RubyModule diametric_peer = persistence.defineModuleUnder("Peer");
+        diametric_peer.defineAnnotatedMethods(DiametricPeer.class);
+
+        RubyClass connection = persistence.defineClassUnder("Connection", runtime.getObject(), CONNECTION_ALLOCATOR);
+        connection.defineAnnotatedMethods(DiametricConnection.class);
+
+        RubyClass uuid = persistence.defineClassUnder("UUID", runtime.getObject(), UUID_ALLOCATOR);
+        uuid.defineAnnotatedMethods(DiametricUUID.class);
+
+        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_listenable = persistence.defineClassUnder("ListenableFuture", runtime.getObject(), LISTENABLE_ALLOCATOR);
+        diametric_listenable.defineAnnotatedMethods(DiametricListenableFuture.class);
+
+        RubyClass diametric_database = persistence.defineClassUnder("Database", runtime.getObject(), DATABASE_ALLOCATOR);
+        diametric_database.defineAnnotatedMethods(DiametricDatabase.class);
+
+        RubyClass diametric_entity = persistence.defineClassUnder("Entity", runtime.getObject(), ENTITY_ALLOCATOR);
+        diametric_entity.defineAnnotatedMethods(DiametricEntity.class);
+
+        RubyModule diametric_utils = persistence.defineModuleUnder("Utils");
+        diametric_utils.defineAnnotatedMethods(DiametricUtils.class);
+
+        setupClojureRT();
+
+        return false;
+    }
+
+    public static final ObjectAllocator CONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricConnection(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator UUID_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricUUID(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator DIAMETRIC_OBJECT_ALLOCATOR = new ObjectAllocator() {
+        DiametricObject diametric_object = null;
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            if (diametric_object == null) diametric_object = new DiametricObject(runtime, klazz);
+            try {
+                return (DiametricObject) diametric_object.clone();
+            } catch (CloneNotSupportedException e) {
+                return new DiametricObject(runtime, klazz);
+            }
+        }
+    };
+
+    public static final ObjectAllocator COLLECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricCollection(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator LISTENABLE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricListenableFuture(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator DATABASE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricDatabase(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator ENTITY_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricEntity(runtime, klazz);
+        }
+    };
+
+    private void setupClojureRT() {
+        clojure.lang.RT.var("clojure.core", "require").invoke(clojure.lang.Symbol.intern("datomic.api"));
+    }
+}

data/ext/diametric/DiametricUUID.java

@@ -0,0 +1,61 @@
+package diametric;
+
+import java.util.UUID;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+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::UUID")
+public class DiametricUUID extends RubyObject {
+    private static final long serialVersionUID = 2083281771243513904L;
+    private java.util.UUID java_uuid = null;
+
+    public DiametricUUID(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz);
+    }
+    
+    void init(java.util.UUID java_uuid) {
+        this.java_uuid = java_uuid;
+    }
+    
+    java.util.UUID getUUID() {
+        return java_uuid;
+    }
+    
+    @JRubyMethod(name = "new", meta = true)
+    public static IRubyObject rbNew(ThreadContext context, IRubyObject klazz) {
+        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::UUID");
+        DiametricUUID diametric_uuid = (DiametricUUID)clazz.allocate();
+        try {
+            java.util.UUID java_uuid = (UUID) clojure.lang.RT.var("datomic.api", "squuid").invoke();
+            diametric_uuid.init(java_uuid);
+            return diametric_uuid;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject to_java(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), java_uuid);
+    }
+    
+    @JRubyMethod
+    public IRubyObject to_s(ThreadContext context) {
+        if (java_uuid == null) return context.getRuntime().getNil();
+        return RubyString.newString(context.getRuntime(), java_uuid.toString());
+    }
+    
+    @JRubyMethod
+    public IRubyObject generate(ThreadContext context, IRubyObject arg) {
+        if (java_uuid == null) return context.getRuntime().getNil();
+        return RubyString.newString(context.getRuntime(), java.util.UUID.randomUUID().toString());
+    }
+}

data/ext/diametric/DiametricUtils.java

@@ -0,0 +1,183 @@
+package diametric;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBignum;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyHash;
+import org.jruby.RubyNil;
+import org.jruby.RubyString;
+import org.jruby.RubyTime;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import datomic.Util;
+
+@JRubyModule(name="Diametric::Persistence::Utils")
+public class DiametricUtils {
+
+    @JRubyMethod(meta=true)
+    public static IRubyObject read_all(ThreadContext context, IRubyObject klazz, IRubyObject arg) {
+        String filename = null;
+        if (arg instanceof RubyString) {
+            filename = DiametricUtils.rubyStringToJava(arg);
+        } else {
+            throw context.getRuntime().newArgumentError("Argument should be filename");
+        }
+        Reader reader = null;
+        try {
+            reader = new FileReader(filename);
+            List list = (List) Util.readAll(reader);
+            RubyArray array = RubyArray.newArray(context.getRuntime(), list.size());
+            array.addAll(list);
+            return array;
+        } catch (Exception e) {
+            throw context.getRuntime().newRuntimeError(e.getMessage());
+        } finally {
+            try {
+                if (reader != null) reader.close();
+            } catch (IOException e) {
+                // no-op
+            }
+        }
+    }
+
+    static String rubyStringToJava(IRubyObject arg) {
+        if (arg instanceof RubyString) {
+            // TODO probably, we need to specify encoding.
+            return (String) ((RubyString)arg).toJava(String.class);
+        } else {
+            return null;
+        }
+    }
+    
+    static Object convertRubyToJava(ThreadContext context, IRubyObject value) {
+        if (value instanceof RubyString) {
+            String str = (String)((RubyString)value).toJava(String.class);
+            try {
+                return (Object)UUID.fromString(str);
+            } catch (IllegalArgumentException e) {
+                return (Object)str;
+            }
+        }
+        if (value instanceof RubyBoolean) return (Object)((RubyBoolean)value).toJava(Boolean.class);
+        if (value instanceof RubyFixnum) return (Object)((RubyFixnum)value).toJava(Long.class);
+        if (value instanceof DiametricUUID) return ((DiametricUUID)value).getUUID();
+        if (value instanceof RubyBignum) {
+            RubyString svalue = (RubyString)((RubyBignum)value).to_s();
+            java.math.BigInteger bivalue = new java.math.BigInteger((String)svalue.toJava(String.class));
+            return (Object)bivalue;
+        }
+        if (value instanceof RubyFloat) return (Object)((RubyFloat)value).toJava(Double.class);
+        if (value instanceof RubyTime) {
+            RubyTime tmvalue = (RubyTime)value;
+            return (Object)tmvalue.getJavaDate();
+        }
+        if (value.respondsTo("to_time")) {
+            // DateTime or Date
+            RubyTime tmvalue = (RubyTime)RuntimeHelpers.invoke(context, value, "to_time");
+            return (Object)tmvalue.getJavaDate();
+        }
+        //System.out.println("NOT YET CONVERTED");
+        //System.out.println("RESPONDSTO? TO_A:" + value.respondsTo("to_a"));
+        if (value.respondsTo("to_a")) { // might be Set for cardinality many type
+            RubyArray ruby_array = (RubyArray)RuntimeHelpers.invoke(context, value, "to_a");
+            List<Object> list = new ArrayList<Object>();
+            while (true) {
+                IRubyObject element = ruby_array.shift(context);
+                if (element.isNil()) break;
+                list.add(DiametricUtils.convertRubyToJava(context, element));
+            }
+            return Collections.unmodifiableList(list);
+        }
+        if (value instanceof DiametricObject) {
+            return ((DiametricObject)value).toJava();
+        }
+        return (Object)value.toJava(Object.class);
+    }
+   
+    static IRubyObject convertJavaToRuby(ThreadContext context, Object value) {
+        Ruby runtime = context.getRuntime();
+        if (value instanceof String) return RubyString.newString(runtime, (String)value);
+        if (value instanceof Boolean) return RubyBoolean.newBoolean(runtime, (Boolean)value);
+        if (value instanceof Long) return RubyFixnum.newFixnum(runtime, (Long)value);
+        if (value instanceof clojure.lang.Keyword) {
+            return RubyString.newString(runtime, ((clojure.lang.Keyword)value).toString());
+        }
+        if (value instanceof java.math.BigInteger) return RubyBignum.newBignum(runtime, ((java.math.BigInteger)value).longValue());
+        if (value instanceof Double) return RubyFloat.newFloat(runtime, (Double)value);
+        if (value instanceof Date) return RubyTime.newTime(runtime, ((Date)value).getTime());
+        if (value instanceof java.util.UUID) {
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::UUID");
+            DiametricUUID diametric_uuid = (DiametricUUID)clazz.allocate();
+            diametric_uuid.init((java.util.UUID)value);
+            return diametric_uuid;
+        }
+        return JavaUtil.convertJavaToUsableRubyObject(runtime, value);
+    }
+
+    static List<Object> convertRubyTxDataToJava(ThreadContext context, IRubyObject arg) {
+        List<Object> tx_data = null;
+        if (arg instanceof RubyArray) {
+            tx_data = fromRubyArray(context, arg);
+        } else {
+            Object obj = arg.toJava(Object.class);
+            if (obj instanceof clojure.lang.PersistentVector) {
+                tx_data = (clojure.lang.PersistentVector)obj;
+            }
+        }
+        return tx_data;
+    }
+
+    private static List<Object> fromRubyArray(ThreadContext context, IRubyObject arg) {
+        RubyArray ruby_tx_data = (RubyArray)arg;
+        List<Object> java_tx_data = new ArrayList<Object>();
+        for (int i=0; i<ruby_tx_data.getLength(); i++) {
+            IRubyObject element = (IRubyObject) ruby_tx_data.get(i);
+            if (element instanceof RubyHash) {
+                RubyHash ruby_hash = (RubyHash) element;
+                Map<Object, Object> keyvals = new HashMap<Object, Object>();
+                while (true) {
+                    IRubyObject pair = ruby_hash.shift(context);
+                    if (pair instanceof RubyNil) break;
+                    Object key = DiametricUtils.convertRubyToJava(context, ((RubyArray) pair).shift(context));
+                    Object value = DiametricUtils.convertRubyToJava(context, ((RubyArray) pair).shift(context));
+                    keyvals.put(key, value);
+                }
+                java_tx_data.add(Collections.unmodifiableMap(keyvals));
+            } else if (element instanceof RubyArray) {
+                RubyArray ruby_array = (RubyArray) element;
+                List<Object> keyvals = new ArrayList<Object>();
+                while (true) {
+                    IRubyObject ruby_element = ruby_array.shift(context);
+                    if (ruby_element instanceof RubyNil) break;
+                    Object key_or_value = DiametricUtils.convertRubyToJava(context, ruby_element);
+                    keyvals.add(key_or_value);
+                }
+                java_tx_data.add(Collections.unmodifiableList(keyvals));
+            } else {
+                continue;
+            }
+        }
+        return java_tx_data;
+    }
+}

data/lib/boolean_type.rb

@@ -0,0 +1,3 @@
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end

data/lib/diametric.rb

@@ -0,0 +1,42 @@
+require "diametric/version"
+require "diametric/entity"
+require "diametric/query"
+require "diametric/persistence"
+require "diametric/errors"
+
+require 'diametric/config'
+
+def is_jruby?
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+    true
+  else
+    false
+  end
+end
+
+if is_jruby?
+  require 'lock_jar'
+  jar_file = File.join(File.dirname(__FILE__), "..", "Jarfile")
+  lock_file = File.join(File.dirname(__FILE__), "..", "Jarfile.lock")
+  current_dir = Dir.pwd
+  Dir.chdir(File.dirname(lock_file))
+  LockJar.lock(jar_file)
+  LockJar.install(lock_file)
+  LockJar.load(lock_file)
+  Dir.chdir(current_dir)
+
+  require 'diametric_service.jar'
+  require 'diametric/diametric'
+  require 'diametric/persistence/peer'
+end
+
+if defined?(Rails)
+  require 'diametric/railtie'
+end
+
+# 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.
+module Diametric
+  extend Diametric::Config
+end

data/lib/diametric/config.rb

@@ -0,0 +1,54 @@
+require 'diametric/config/environment'
+require 'diametric/persistence'
+
+module Diametric
+  # Program-level configuration services including configuration loading and base connections.
+  module Config
+    extend self
+
+    # The current configuration Diametric will use in {#connect!}
+    #
+    # @return [Hash]
+    def configuration
+      @configuration ||= {}
+    end
+
+    # Determine if Diametric has been configured
+    #
+    # @return [Boolean]
+    def configured?
+      configuration.present?
+    end
+
+    # Load settings from a compliant diametric.yml file and make a connection. This can be used for
+    # easy setup with frameworks other than Rails.
+    #
+    # See {Persistence} for valid options.
+    #
+    # @example Configure Diametric.
+    #   Diametric.load_and_connect!("/path/to/diametric.yml")
+    #
+    # @param [ String ] path The path to the file.
+    # @param [ String, Symbol ] environment The environment to load.
+    def load_and_connect!(path, environment = nil)
+      settings = Environment.load_yaml(path, environment)
+      @configuration = settings.with_indifferent_access
+      connect!(configuration)
+      peer_setup if Diametric::Persistence.peer?
+      configuration
+    end
+
+    # Establish a base connection from the supplied configuration hash.
+    #
+    # @param [ Hash ] configuration The configuration of the database to connect to. See {Persistence.establish_base_connection} for valid options.
+    def connect!(configuration)
+      ::Diametric::Persistence.establish_base_connection(configuration)
+    end
+
+    private
+    def peer_setup
+      load File.join(File.dirname(__FILE__), '..', 'tasks', 'create_schema.rb')
+      Rake::Task["diametric:create_schema_for_peer"].invoke
+    end
+  end
+end