diametric 0.1.2-java → 0.1.3-java

data/ext/diametric/DiametricSet.java

@@ -31,6 +31,13 @@ public class DiametricSet extends RubyObject {
     private Integer count = null;  // unable to count the vector size that exceeds Integer
     private DiametricCommon common = null;
 
+    static IRubyObject getDiametricSet(ThreadContext context, Set value) {
+        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Set");
+        DiametricSet diametric_set = (DiametricSet)clazz.allocate();
+        diametric_set.init(value);
+        return diametric_set;
+    }
+
     public DiametricSet(Ruby runtime, RubyClass klazz) {
         super(runtime, klazz);
     }
@@ -242,9 +249,9 @@ public class DiametricSet extends RubyObject {
             Var var = DiametricService.getFn("clojure.set", "union");
             if (set instanceof HashSet) {
                 PersistentHashSet value = convertHashSetToPersistentHashSet(set);
-                return DiametricUtils.getDiametricSet(context, (Set)var.invoke(value, other));
+                return DiametricSet.getDiametricSet(context, (Set)var.invoke(value, other));
             } else {
-                return DiametricUtils.getDiametricSet(context, (Set)var.invoke(set, other));
+                return DiametricSet.getDiametricSet(context, (Set)var.invoke(set, other));
             }
         } catch (Throwable t) {
             throw context.getRuntime().newRuntimeError(t.getMessage());
@@ -259,9 +266,9 @@ public class DiametricSet extends RubyObject {
             Var var = DiametricService.getFn("clojure.set", "difference");
             if (set instanceof HashSet) {
                 PersistentHashSet value = convertHashSetToPersistentHashSet(set);
-                return DiametricUtils.getDiametricSet(context, (Set)var.invoke(value, other));
+                return DiametricSet.getDiametricSet(context, (Set)var.invoke(value, other));
             } else {
-                return DiametricUtils.getDiametricSet(context, (Set)var.invoke(set, other));
+                return DiametricSet.getDiametricSet(context, (Set)var.invoke(set, other));
             }
         } catch (Throwable t) {
             throw context.getRuntime().newRuntimeError(t.getMessage());

data/ext/diametric/DiametricUUID.java

@@ -17,6 +17,13 @@ public class DiametricUUID extends RubyObject {
     private static final long serialVersionUID = 2083281771243513904L;
     private java.util.UUID java_uuid = null;
 
+    static IRubyObject getDiametricUUID(ThreadContext context, java.util.UUID value) {
+        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;
+    }
+
     public DiametricUUID(Ruby runtime, RubyClass klazz) {
         super(runtime, klazz);
     }
@@ -34,7 +41,7 @@ public class DiametricUUID extends RubyObject {
         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();
+            java.util.UUID java_uuid = (UUID) DiametricService.getFn("datomic.api", "squuid").invoke();
             diametric_uuid.init(java_uuid);
             return diametric_uuid;
         } catch (Throwable t) {

data/ext/diametric/DiametricUtils.java

@@ -6,10 +6,7 @@ import java.io.Reader;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
 
@@ -23,6 +20,7 @@ import org.jruby.RubyFloat;
 import org.jruby.RubyHash;
 import org.jruby.RubyNil;
 import org.jruby.RubyString;
+import org.jruby.RubySymbol;
 import org.jruby.RubyTime;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.anno.JRubyModule;
@@ -31,11 +29,14 @@ import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
+import clojure.lang.APersistentMap;
 import clojure.lang.APersistentVector;
 import clojure.lang.IPersistentSet;
+import clojure.lang.Keyword;
 import clojure.lang.LazySeq;
 import clojure.lang.PersistentHashSet;
 import clojure.lang.PersistentVector;
+import clojure.lang.Var;
 import datomic.Util;
 
 @JRubyModule(name="Diametric::Persistence::Utils")
@@ -67,6 +68,24 @@ public class DiametricUtils {
         }
     }
 
+    @JRubyMethod(meta=true)
+    public static IRubyObject read_string(ThreadContext context, IRubyObject klazz, IRubyObject arg) {
+        if (!(arg instanceof RubyString)) {
+            throw context.getRuntime().newArgumentError("Argument should be string");
+        }
+        RubyString ruby_string = (RubyString)arg;
+        try {
+            Var reader = DiametricService.getFn("clojure.core", "read-string");
+            Object value = reader.invoke((String)ruby_string.asJavaString());
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Object");
+            DiametricObject diametric_object = (DiametricObject)clazz.allocate();
+            diametric_object.update(value);
+            return diametric_object;
+        } catch (Exception e) {
+            throw context.getRuntime().newRuntimeError(e.getMessage());
+        }
+    }
+
     static String rubyStringToJava(IRubyObject arg) {
         if (arg instanceof RubyString) {
             // TODO probably, we need to specify encoding.
@@ -80,11 +99,7 @@ public class DiametricUtils {
         if (value instanceof RubyNil) return null;
         if (value instanceof RubyString) {
             String str = (String)((RubyString)value).toJava(String.class);
-            try {
-                return (Object)UUID.fromString(str);
-            } catch (IllegalArgumentException e) {
-                return (Object)str;
-            }
+            return getStringOrUUID(str);
         }
         if (value instanceof RubyBoolean) return (Object)((RubyBoolean)value).toJava(Boolean.class);
         if (value instanceof RubyFixnum) return (Object)((RubyFixnum)value).toJava(Long.class);
@@ -99,6 +114,16 @@ public class DiametricUtils {
             RubyTime tmvalue = (RubyTime)value;
             return (Object)tmvalue.getJavaDate();
         }
+        if (value instanceof RubySymbol) {
+            // schema or data keyword
+            RubyString edn_string = (RubyString)RuntimeHelpers.invoke(context, value, "to_s");
+            return (Object)Keyword.intern((String)edn_string.asJavaString());
+        }
+        if (value.respondsTo("to_edn") && value.respondsTo("symbol")) {
+            // EDN::Type::Symbol (query)
+            RubyString edn_string = (RubyString)RuntimeHelpers.invoke(context, value, "to_edn");
+            return (Object)clojure.lang.Symbol.intern((String)edn_string.asJavaString());
+        }
         if (value.respondsTo("to_time")) {
             // DateTime or Date
             RubyTime tmvalue = (RubyTime)RuntimeHelpers.invoke(context, value, "to_time");
@@ -110,15 +135,23 @@ public class DiametricUtils {
         }
         //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
-            return getList(context, value);
-        }
+        //if (value.respondsTo("to_a")) { // might be Set for cardinality many type
+        //    return getList(context, value);
+        //}
         if (value instanceof DiametricObject) {
             return ((DiametricObject)value).toJava();
         }
         return (Object)value.toJava(Object.class);
     }
 
+    static Object getStringOrUUID(String str) {
+        try {
+            return (Object)UUID.fromString(str);
+        } catch (IllegalArgumentException e) {
+            return (Object)str;
+        }
+    }
+
     static IPersistentSet getPersistentSet(ThreadContext context, IRubyObject value) {
         return PersistentHashSet.create((List)value.callMethod(context, "to_a"));
     }
@@ -147,79 +180,74 @@ public class DiametricUtils {
         if (value instanceof Double) return RubyFloat.newFloat(runtime, (Double)value);
         if (value instanceof Date) return RubyTime.newTime(runtime, ((Date)value).getTime());
         if (value instanceof Set) {
-            return getDiametricSet(context, (Set)value);
+            return DiametricSet.getDiametricSet(context, (Set)value);
         }
         if ((value instanceof APersistentVector) ||
                 (value instanceof LazySeq) ||
                 (value instanceof PersistentVector.ChunkedSeq)){
-            return getDiametricCollection(context, (List)value);
+            return DiametricCollection.getDiametricCollection(context, (List)value);
+        }
+        if (value instanceof datomic.Entity) {
+            return DiametricEntity.getDiametricEntity(context, value);
         }
         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 DiametricUUID.getDiametricUUID(context, (java.util.UUID)value);
         }
         return JavaUtil.convertJavaToUsableRubyObject(runtime, value);
     }
 
-    static IRubyObject getDiametricSet(ThreadContext context, Set value) {
-        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Set");
-        DiametricSet diametric_set = (DiametricSet)clazz.allocate();
-        diametric_set.init(value);
-        return diametric_set;
-    }
-
-    static IRubyObject getDiametricCollection(ThreadContext context, List value) {
-        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Collection");
-        DiametricCollection diametric_collection = (DiametricCollection)clazz.allocate();
-        diametric_collection.init((List)value);
-        return diametric_collection;
-    }
-
-    static List<Object> convertRubyTxDataToJava(ThreadContext context, IRubyObject arg) {
-        List<Object> tx_data = null;
+    static PersistentVector convertRubyTxDataToJava(ThreadContext context, IRubyObject arg) {
         if (arg instanceof RubyArray) {
-            tx_data = fromRubyArray(context, arg);
+            return fromRubyArray(context, (RubyArray)arg);
         } else {
             Object obj = arg.toJava(Object.class);
             if (obj instanceof clojure.lang.PersistentVector) {
-                tx_data = (clojure.lang.PersistentVector)obj;
+                return (clojure.lang.PersistentVector)obj;
             }
         }
-        return tx_data;
+        return null;
     }
 
-    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);
+    static PersistentVector fromRubyArray(ThreadContext context, RubyArray ruby_array) {
+        Var var = DiametricService.getFn("clojure.core", "vector");
+        PersistentVector clj_tx_data = (PersistentVector)var.invoke();
+        Var adder = DiametricService.getFn("clojure.core", "conj");
+        for (int i=0; i<ruby_array.getLength(); i++) {
+            Object element = ruby_array.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));
+                APersistentMap map = fromRubyHash(context, (RubyHash)element);
+                clj_tx_data = (PersistentVector)adder.invoke(clj_tx_data, map);
             } 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));
+                PersistentVector vector = fromRubyArray(context, (RubyArray)element);
+                clj_tx_data = (PersistentVector)adder.invoke(clj_tx_data, vector);
+            } else if (element instanceof IRubyObject) {
+                clj_tx_data =
+                        (PersistentVector)adder.invoke(clj_tx_data, DiametricUtils.convertRubyToJava(context, (IRubyObject)element));
+            } else if (element instanceof String) {
+                clj_tx_data = (PersistentVector)adder.invoke(clj_tx_data, getStringOrUUID((String)element));
             } else {
-                continue;
+                clj_tx_data = (PersistentVector)adder.invoke(clj_tx_data, element);
+            }
+        }
+        return clj_tx_data;
+    }
+
+    private static APersistentMap fromRubyHash(ThreadContext context, RubyHash ruby_hash) {
+        Var var = DiametricService.getFn("clojure.core", "hash-map");
+        APersistentMap map = (APersistentMap)var.invoke();
+        Var associator = DiametricService.getFn("clojure.core", "assoc");
+        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));
+            if (value instanceof RubyHash) {
+                value = fromRubyHash(context, (RubyHash)value);
+            } else if (value instanceof RubyArray) {
+                value = fromRubyArray(context, (RubyArray)value);
             }
+            map = (APersistentMap)associator.invoke(map, key, value);
         }
-        return java_tx_data;
+        return map;
     }
 }

data/lib/diametric.rb

@@ -1,5 +1,6 @@
 require "diametric/version"
 require "diametric/entity"
+require "diametric/associations/collection"
 require "diametric/query"
 require "diametric/persistence"
 require "diametric/errors"

data/lib/diametric/associations/collection.rb

@@ -0,0 +1,103 @@
+module Diametric
+  module Associations
+    class Collection
+      def initialize(base, name, enum=nil, &block)
+        @base = base
+        @attribute_name = name
+        @data = Set.new(enum, &block)
+      end
+
+      def add(*entities)
+        old_data = @data.dup
+        entities.each do |entity|
+          if entity.dbid.nil? || entity.dbid.to_i < 0
+            entity.save
+          end
+          @data << entity.dbid
+        end
+        if old_data != @data
+          @base.send("#{@attribute_name}=", self)
+        end
+      end
+      alias :<< :add
+
+      def add_reified_entities(*entities)
+        entities.each do |entity|
+          @data << entity
+        end
+        @base.send("clean_#{@attribute_name}=", self)
+      end
+
+      def delete(*entities)
+        entities.each do |entity|
+          return unless self.include?(entity)
+          if entity.is_a?(Fixnum) || entity.respond_to?(:to_i)
+            # dbid or dbid object
+            @data.delete_if {|e| e.to_i == entity.to_i}
+          elsif entity.respond_to?(:dbid)
+            # reified or created entity
+            @data.delete_if {|e| e.dbid == entity.dbid}
+          end
+        end
+      end
+
+      def destroy(*entities)
+        entities.each do |entity|
+          return unless self.include?(entity)
+          if entity.respond_to? :destroy
+            entity.destroy
+          end
+          self.delete(entity)
+        end
+      end
+
+      def include?(o)
+        if o.is_a?(Fixnum) || o.respond_to?(:to_i)
+          @data.find_all {|e| e.respond_to?(:to_i)}.collect(&:to_i).include?(o.to_i)
+        elsif o.respond_to?(:dbid)
+          @data.find_all {|e| e.respond_to?(:dbid)}.collect(&:dbid).include?(o.dbid)
+        else
+          false
+        end
+      end
+      alias :member? :include?
+
+      def &(enum)
+        # this method is used to test the given class is Set or not.
+        # don't delete this method.
+        n = self.class.new
+        @data.each { |o| n.add(o) if include?(o) }
+        n
+      end
+      alias intersection &
+
+      def inspect
+        return sprintf('#<%s: {%s}>', self.class, @data.to_a.inspect[1..-2])
+      end
+
+      def replace(entities)
+        @data = Set.new
+        entities.each do |entity|
+          if entity.dbid.nil? || entity.dbid.to_i < 0
+            @data << entity.dbid if entity.save
+          else
+            @data << entity
+          end
+        end
+        self
+      end
+
+      def method_missing(method, *args, &block)
+        if !args.empty? && block
+          @data.send(method, args, &block)
+        elsif !args.empty?
+          @data.send(method, args)
+        elsif block
+          @data.send(method, &block)
+        else
+          @data.send(method)
+        end
+      end
+    end
+  end
+end

data/lib/diametric/entity.rb

@@ -51,7 +51,7 @@ module Diametric
       :cardinality => :one
     }
 
-    @temp_ref = -1000
+    @temp_ref = -1000000
 
     def self.included(base)
       base.send(:extend, ClassMethods)
@@ -210,13 +210,7 @@ module Diametric
       # @return [Array] A Datomic schema, as Ruby data that can be
       #   converted to EDN.
       def schema
-        return peer_schema if self.instance_variable_get("@peer")
-        rest_schema
-      end
-
-      def rest_schema
         defaults = {
-          :"db/id" => tempid(:"db.part/db"),
           :"db/cardinality" => :"db.cardinality/one",
           :"db.install/_attribute" => :"db.part/db"
         }
@@ -238,13 +232,13 @@ module Diametric
           schema << defaults.merge({
                                      :"db/ident" => namespace(prefix, attribute),
                                      :"db/valueType" => value_type(value_type),
+                                     :"db/id" => tempid(:"db.part/db")
                                    }).merge(opts)
         end
-
         enum_schema = [
           :"db/add", tempid(:"db.part/user"), :"db/ident"
         ]
-        prefix = self.name.downcase
+        prefix = self.to_s.underscore
         @enums.each do |key, values|
           values.each do |value|
             ident_value = :"#{prefix}.#{key.downcase}/#{value.to_s.sub(/_/, "-").downcase}"
@@ -255,48 +249,6 @@ module Diametric
         schema_array
       end
 
-      # Generates a Datomic schema for a model's attributes.
-      #
-      # @return [Array] A Datomic schema, as Ruby data that can be
-      #   converted to EDN.
-      def peer_schema
-        defaults = {
-          ":db/cardinality" => ":db.cardinality/one",
-          ":db.install/_attribute" => ":db.part/db"
-        }
-
-        schema_array = @attributes.reduce([]) do |schema, (attribute, opts)|
-          opts = opts.dup
-          value_type = opts.delete(:value_type)
-
-          unless opts.empty?
-            opts[:cardinality] = namespace("db.cardinality", opts[:cardinality])
-            opts[:unique] = namespace("db.unique", opts[:unique]) if opts[:unique]
-            opts = opts.map { |k, v|
-              k = namespace("db", k)
-              [k, v]
-            }
-            opts = Hash[*opts.flatten]
-          end
-
-          schema << defaults.merge({
-                                     ":db/id" => Diametric::Persistence::Peer.tempid(":db.part/db"),
-                                     ":db/ident" => namespace(prefix, attribute),
-                                     ":db/valueType" => value_type(value_type),
-                                   }).merge(opts)
-        end
-
-        prefix = self.name.downcase
-        @enums.each do |key, values|
-          values.each do |value|
-            ident_value = ":#{prefix}.#{key.downcase}/#{value.to_s.sub(/_/, "-").downcase}"
-            es = [":db/add", Diametric::Persistence::Peer.tempid(":db.part/user"), ":db/ident", ident_value]
-            schema_array << es
-          end
-        end
-        schema_array
-      end
-
       # Given a set of Ruby data returned from a Datomic query, this
       # can re-hydrate that data into a model instance.
       #
@@ -316,13 +268,20 @@ module Diametric
         parent.class.attribute_names.each do |e|
           if parent.class.attributes[e][:value_type] == "ref"
             ref = parent.instance_variable_get("@#{e.to_s}")
-            if ref.is_a?(Fixnum) || ref.is_a?(Java::DatomicQuery::EntityMap)
+            if ref.is_a?(Fixnum) ||
+              (self.instance_variable_get("@peer") && ref.is_a?(Diametric::Persistence::Entity))
               child = reify(ref, connection)
               child = resolve_ref_dbid(child, connection)
               parent.instance_variable_set("@#{e.to_s}", child)
+            elsif ref.is_a?(Diametric::Associations::Collection)
+              children = Diametric::Associations::Collection.new(parent, e.to_s)
+              ref.each do |entity|
+                children.add_reified_entities(reify(entity, connection))
+              end
+              parent.instance_variable_set("@#{e.to_s}", children)
             elsif ref.is_a?(Set)
               children = ref.inject(Set.new) do |memo, entity|
-               child = reify(entity, connection)
+                child = reify(entity, connection)
                 memo.add(child)
                 memo
               end
@@ -334,6 +293,38 @@ module Diametric
       end
 
       def reify(thing, conn_or_db=nil, resolve=false)
+        return peer_reify(thing, conn_or_db, resolve) if self.instance_variable_get("@peer")
+        rest_reify(thing, resolve)
+      end
+
+      def rest_reify(dbid, resolve)
+        query = [
+          :find, ~"?ident", ~"?v",
+          :in, ~"\$", [~"?e"],
+          :where, [~"?e", ~"?a", ~"?v"], [~"?a", :"db/ident", ~"?ident"]
+        ]
+        entities = self.q(query, [[dbid]])
+        class_name = to_classname(entities.first.first)
+        instance = eval("#{class_name}.new")
+        entities.each do |k, v|
+          matched_data = /([a-zA-Z0-9_\.]+)\/([a-zA-Z0-9_]+)/.match(k.to_s)
+          attribute = instance.send(matched_data[2])
+          if attribute && attribute.is_a?(Diametric::Associations::Collection)
+            attribute.add_reified_entities(v)
+          else
+            instance.send("clean_#{matched_data[2]}=", v)
+          end
+        end
+        instance.send("dbid=", dbid)
+
+        if resolve
+          instance = resolve_ref_dbid(instance, nil)
+        end
+
+        instance
+      end
+
+      def peer_reify(thing, conn_or_db=nil, resolve=false)
         conn_or_db ||= Diametric::Persistence::Peer.connect.db
 
         if conn_or_db.respond_to?(:db)
@@ -359,13 +350,11 @@ module Diametric
           return thing
         end
         first_key = entity.keys.first
-        match_data = /:([a-zA-Z0-9_]+)\/([a-zA-Z0-9_]+)/.match(first_key)
-        entity_name = match_data[1].capitalize.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}"}
-        instance = eval("#{entity_name}.new")
-        instance.send("#{match_data[2]}=", entity[first_key])
-        entity.keys[1..-1].each do |key|
-          match_data = /:([a-zA-Z0-9_]+)\/([a-zA-Z0-9_]+)/.match(key)
-          instance.send("#{match_data[2]}=", entity[key])
+        class_name = to_classname(first_key)
+        instance = eval("#{class_name}.new")
+        entity.keys.each do |key|
+          matched_data = /:([a-zA-Z0-9_\.]+)\/([a-zA-Z0-9_]+)/.match(key)
+          instance.send("clean_#{matched_data[2]}=", entity[key])
         end
         instance.send("dbid=", Diametric::Persistence::Object.new(entity.get("db/id")))
 
@@ -376,6 +365,34 @@ module Diametric
         instance
       end
 
+      def to_classname(key)
+        names = []
+        # drops the first character ":"
+        key = key.to_s
+        if key[0] == ":"
+          key = key[1..-1]
+        end
+        key.chars.inject("") do |memo, c|
+          if c == "/"
+            # means the end of class name
+            names << memo
+            break
+          elsif c == "."
+            # namespace delimiter
+            names << memo
+            memo = ""
+          elsif c == "-"
+            # Clojure uses - for name, but Ruby can't
+            # converts dash to underscore
+            memo << "_"
+          else
+            memo << c
+          end
+          memo
+        end
+        names.collect(&:camelize).join("::")
+      end
+
       def find(id)
         if self.instance_variable_get("@peer")
           connection ||= Diametric::Persistence::Peer.connect
@@ -383,19 +400,6 @@ module Diametric
         reify(id, connection)
       end
 
-      # Returns the prefix for this model used in Datomic. Can be
-      # overriden by declaring {#namespace_prefix}
-      #
-      # @example
-      #   Mouse.prefix #=> "mouse"
-      #   FireHouse.prefix #=> "fire_house"
-      #   Person::User.prefix #=> "person.user"
-      #
-      # @return [String]
-      def prefix
-        @namespace_prefix || self.to_s.underscore.sub('/', '.')
-      end
-
       # Create a temporary id placeholder.
       #
       # @param e [*#to_edn] Elements to put in the placeholder. Should
@@ -405,16 +409,25 @@ module Diametric
       # @return [EDN::Type::Unknown] Temporary id placeholder.
       def tempid(*e)
         if self.instance_variable_get("@peer")
-          if e[0].to_s.include?("user")
-            return Diametric::Persistence::Peer.tempid(":db.part/user")
-          else
-            return Diametric::Persistence::Peer.tempid(":db.part/db")
-          end
+          Diametric::Persistence::Peer.tempid(*e)
         else
-          EDN.tagged_element('db/id', e)
+          Diametric::Persistence::REST.tempid(*e)
         end
       end
 
+      # Returns the prefix for this model used in Datomic. Can be
+      # overriden by declaring {#namespace_prefix}
+      #
+      # @example
+      #   Mouse.prefix #=> "mouse"
+      #   FireHouse.prefix #=> "fire_house"
+      #   Person::User.prefix #=> "person.user"
+      #
+      # @return [String]
+      def prefix
+        @namespace_prefix || self.to_s.underscore.gsub('/', '.')
+      end
+
       # Namespace a attribute for Datomic.
       #
       # @param ns [#to_s] Namespace.
@@ -422,11 +435,7 @@ module Diametric
       #
       # @return [Symbol] Namespaced attribute.
       def namespace(ns, attribute)
-        if self.instance_variable_get("@peer")
-          ":" + [ns.to_s, attribute.to_s].join("/")
-        else
-          [ns.to_s, attribute.to_s].join("/").to_sym
-        end
+        [ns.to_s, attribute.to_s].join("/").to_sym
       end
 
       # Raise an error if validation failed.
@@ -457,13 +466,72 @@ module Diametric
         define_attribute_method name
 
         define_method(name) do
-          instance_variable_get("@#{name}")
+          ivar = instance_variable_get("@#{name}")
+          if ivar.nil? &&
+              self.class.attributes[name][:value_type] == Ref &&
+              self.class.attributes[name][:cardinality] == :many
+            ivar = Diametric::Associations::Collection.new(self, name)
+          end
+          ivar
         end
 
         define_method("#{name}=") do |value|
           send("#{name}_will_change!") unless value == instance_variable_get("@#{name}")
-          if cardinality == :many
-            value = Set.new(value)
+          case self.class.attributes[name][:value_type]
+          when Ref
+            case cardinality
+            when :many
+              if value.is_a?(Enumerable) && value.first.respond_to?(:save)
+                # entity type
+                ivar = send("#{name}")
+                instance_variable_set("@#{name}", ivar.replace(value))
+              elsif value.is_a?(Diametric::Associations::Collection)
+                instance_variable_set("@#{name}", value)
+              elsif value.is_a?(Enumerable)
+                # enum type
+                # however, falls here when empty array is given for entity type
+                instance_variable_set("@#{name}", Set.new(value))
+              end
+            when :one
+              if value.respond_to?(:save)
+                # entity type
+                if value.save
+                  instance_variable_set("@#{name}", value.dbid)
+                end
+              else
+                # enum type
+                instance_variable_set("@#{name}", value)
+              end
+            end
+          else   # not Ref
+            case cardinality
+            when :many
+              instance_variable_set("@#{name}", Set.new(value))
+            when :one
+              instance_variable_set("@#{name}", value)
+            end
+          end
+        end
+
+        define_method("clean_#{name}=") do |value|
+          if self.class.attributes[name][:value_type] != Ref && cardinality == :many
+            if value.is_a? Enumerable
+              value = Set.new(value)
+            else
+              # used from rest reify
+              ivar = instance_variable_get("@#{name}")
+              ivar ||= Set.new
+              value = ivar.add(value)
+            end
+          end
+          if self.class.attributes[name][:value_type] == Ref &&
+              cardinality == :many &&
+              !(value.is_a? Diametric::Associations::Collection)
+            if value.is_a? Enumerable
+              value = Diametric::Associations::Collection.new(self, name, value)
+            else
+              value = Diametric::Associations::Collection.new(self, name, [value])
+            end
           end
           instance_variable_set("@#{name}", value)
         end
@@ -512,7 +580,6 @@ module Diametric
       attribute_names.each do |attribute_name|
         cardinality = self.class.attributes[attribute_name.to_sym][:cardinality]
 
-        #if cardinality == :many && self.class.instance_variable_get("@peer").nil?
         if cardinality == :many
           txes += cardinality_many_tx_data(attribute_name)
         else
@@ -521,42 +588,38 @@ module Diametric
       end
 
       if entity_tx.present?
-        if self.class.instance_variable_get("@peer")
-          @dbid ||= tempid
-          txes << entity_tx.merge({":db/id" => dbid})
-        else
-          txes << entity_tx.merge({:"db/id" => dbid || tempid})
-        end
+        @dbid ||= tempid
+        txes << entity_tx.merge({:"db/id" => dbid})
       end
       txes
     end
 
     def cardinality_many_tx_data(attribute_name)
-      prev = Array(self.changed_attributes[attribute_name]).to_set
+      changed = self.changed_attributes[attribute_name]
+      prev =
+        changed.is_a?(Diametric::Associations::Collection) ? changed.to_set : Array(changed).to_set
       curr = self.send(attribute_name)
+      curr = curr.is_a?(Diametric::Associations::Collection) ? curr.to_set : curr
 
       protractions = curr - prev
       retractions = prev - curr
 
       namespaced_attribute = self.class.namespace(self.class.prefix, attribute_name)
       txes = []
-      if self.class.instance_variable_get("@peer")
-        @dbid ||= tempid
-        txes_data(txes, ":db/retract", namespaced_attribute, retractions) unless retractions.empty?
-        txes_data(txes, ":db/add", namespaced_attribute, protractions) unless protractions.empty?
-      else
-        txes << [:"db/retract", (dbid || tempid), namespaced_attribute, retractions.to_a] unless retractions.empty?
-        txes << [:"db/add", (dbid || tempid) , namespaced_attribute, protractions.to_a] unless protractions.empty?
-      end
+      @dbid ||= tempid
+      txes << [:"db/retract", dbid, namespaced_attribute, retractions.to_a] unless retractions.empty?
+      txes << [:"db/add", dbid , namespaced_attribute, protractions.to_a] unless protractions.empty?
       txes
     end
 
+=begin
     def txes_data(txes, op, namespaced_attribute, set)
       set.to_a.each do |s|
         value = s.respond_to?(:dbid) ? s.dbid : s
         txes << [op, @dbid, namespaced_attribute, value]
       end
     end
+=end
 
     # Returns hash of all attributes for this object
     #