diametric 0.0.4 → 0.1.1

data/lib/diametric/generators/active_model.rb

@@ -8,8 +8,8 @@ module Diametric
         "#{klass}.all"
       end
 
-      def self.find(klass, params=nil)
-        "#{klass}.get(#{params})"
+      def self.find(klass, params=nil, connection=nil, resolve=false)
+        "#{klass}.get(#{params}, #{connection}, #{resolve})"
       end
 
       def self.build(klass, params=nil)

data/lib/diametric/persistence.rb

@@ -37,7 +37,6 @@ module Diametric
 
     def self.persistence_class(uri)
       if uri =~ /^datomic:/
-        require 'diametric/persistence/peer'
         @conn_type = :peer
         Peer
       else

data/lib/diametric/persistence/common.rb

@@ -36,25 +36,44 @@ module Diametric
       end
 
       module ClassMethods
-        def create_schema
-          transact(schema)
+        def create_schema(connection=nil)
+          if self.instance_variable_get("@peer")
+            connection ||= Diametric::Persistence::Peer.connect
+            connection.transact(schema)
+          else
+            transact(schema)
+          end
         end
 
-        def all
-          Diametric::Query.new(self).all
+        def all(connection=nil, resolve=false)
+          if self.instance_variable_get("@peer")
+            connection ||= Diametric::Persistence::Peer.connect
+          end
+          Diametric::Query.new(self, connection, resolve).all
         end
 
-        def first(conditions = {})
-          where(conditions).first
+        def first(conditions = {}, connection=nil, resolve=false)
+          if self.instance_variable_get("@peer")
+            connection ||= Diametric::Persistence::Peer.connect
+          end
+          where(conditions, connection, resolve).first
         end
 
-        def where(conditions = {})
-          query = Diametric::Query.new(self)
+        def where(conditions = {}, connection=nil, resolve=false)
+          if self.instance_variable_get("@peer")
+            connection ||= Diametric::Persistence::Peer.connect
+          end
+          query = Diametric::Query.new(self, connection, resolve)
           query.where(conditions)
         end
 
         def filter(*filter)
-          query = Diametric::Query.new(self)
+          if self.instance_variable_get("@peer")
+            connection = Diametric::Persistence::Peer.connect
+          else
+            connection = nil
+          end
+          query = Diametric::Query.new(self, connection, true)
           query.filter(*filter)
         end
       end

data/lib/diametric/persistence/peer.rb

@@ -1,118 +1,153 @@
-unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-  raise "This module requires the use of JRuby."
-end
-
-require 'diametric'
 require 'diametric/persistence/common'
 
-require 'java'
-require 'lock_jar'
-lockfile = File.expand_path( "../../../../Jarfile.lock", __FILE__ )
-# Loads the classpath with Jars from the lockfile
-LockJar.load(lockfile)
-
-require 'jrclj'
-java_import "clojure.lang.Keyword"
-
 module Diametric
   module Persistence
     module Peer
-      include_package "datomic"
 
-      @connection = nil
-      @persisted_classes = Set.new
+      def save(connection=nil)
+        return false unless valid?
+        return true unless changed?
+        connection ||= Diametric::Persistence::Peer.connect
 
-      def self.included(base)
-        base.send(:include, Diametric::Persistence::Common)
-        base.send(:extend, ClassMethods)
-        @persisted_classes.add(base)
-      end
+        parsed_data = []
+        parse_tx_data(tx_data, parsed_data)
 
-      def self.connection
-        @connection
-      end
+        map = connection.transact(parsed_data).get
 
-      def self.create_schemas
-        @persisted_classes.each do |klass|
-          klass.create_schema
-        end
-      end
+        resolve_changes([self], map)
 
-      module ClassMethods
-        include_package "datomic"
+        map
+      end
 
-        def connect(options = {})
-          uri = options[:uri]
-          Java::Datomic::Peer.create_database(uri)
-          @connection = Java::Datomic::Peer.connect(uri)
+      def resolve_tempid(map, id)
+        if id.to_s =~ /-\d+/
+          return Diametric::Persistence::Peer.resolve_tempid(map, id)
         end
+        return id
+      end
 
-        def disconnect
-          @connection = nil
+      def parse_tx_data(data, result)
+        queue = []
+        data.each do |c_data|
+          if c_data.is_a? Hash
+            parse_hash_data(c_data, result, queue)
+          elsif c_data.is_a? Array
+            parse_array_data(c_data, result)
+          end
         end
+        parse_tx_data(queue, result) unless queue.empty?
+      end
 
-        def connection
-          @connection || Diametric::Persistence::Peer.connection
-        end
+      def parse_hash_data(c_hash, result, queue)
+          hash = {}
+          c_hash.each do |c_key, c_value|
+            if c_value.respond_to?(:tx_data)
+              if c_value.tx_data.empty?
+                hash[c_key] = c_value.dbid
+              else
+                c_value.dbid = c_value.tempid
+                hash[c_key] = c_value.dbid
+                queue << c_value.tx_data.first
+              end
+            elsif c_value.is_a? Set
+              set_value = Set.new
+              c_value.each do |s|
+                if s.respond_to?(:tx_data) && s.tx_data.empty?
+                  set_value << s.dbid
+                elsif s.respond_to?(:tx_data)
+                  set_value << s.tx_data[":db/id"]
+                  parsed_tx_data(s, result)
+                else
+                  set_value << s
+                end
+              end
+              hash[c_key] = set_value
+            elsif c_value.respond_to?(:eid)
+              hash[c_key] = c_value.eid
+            else
+              hash[c_key] = c_value
+            end
+          end
+          result << hash
+      end
 
-        def transact(data)
-          data = clj.edn_convert(data)
-          res = connection.transact(data)
-          res.get
+      def parse_array_data(c_array, result)
+        array = []
+        c_array.each do |c_value|
+          if c_value.respond_to?(:to_a)
+            a_values = []
+            c_value.to_a.each do |a_value|
+              if a_value.respond_to?(:tx_data) && a_value.tx_data.empty?
+                a_values << a_value.dbid
+              else
+                a_values << a_value
+              end
+            end
+            array << a_values
+          else
+            array << c_value
+          end
         end
+        result << array
+      end
 
-        def get(dbid)
-          entity = self.new
-          self.all.each do |e|
-            next unless e.dbid == dbid.to_i
-            e.attribute_names.each {|n| entity.send((n.to_s+"=").to_sym, e.send(n))}
+      def resolve_changes(parents, map)
+        queue = []
+        parents.each do |child|
+          child.attributes.each do |a_key, a_val|
+            if a_val.respond_to?(:tx_data)
+              queue << a_val
+            end
           end
-          entity.dbid = dbid.to_i
-          entity
+          child.instance_variable_set("@previously_changed", child.changes)
+          child.changed_attributes.clear
+          child.dbid = resolve_tempid(map, child.dbid)
+          child.instance_variable_set("@tx_map", map)
         end
+        resolve_changes(queue, map) unless queue.empty?
+      end
 
-        def q(query, args)
-          Java::Datomic::Peer.q(clj.edn_convert(query), connection.db, *args)
-        end
+      def retract_entity(dbid)
+        Diametric::Persistence::Peer.retract_entity(dbid)
+      end
 
-        def clj
-          @clj ||= JRClj.new
+      def method_missing(method_name, *args, &block)
+        result = /(.+)_from_this_(.+)/.match(method_name)
+        if result
+          query_string = ":#{result[1]}/_#{result[2]}"
+          entities = Diametric::Persistence::Peer.reverse_q(args[0].db, self.dbid, query_string)
+          entities.collect {|e| self.class.from_dbid_or_entity(e, args[0])}
+        else
+          super
         end
       end
 
-      extend ClassMethods
-
-      # Save the entity
-      #
-      # @example Save the entity.
-      #   entity.save
-      #
-      # @return [ true, false ] True is success, false if not.
-      def save
-        return false unless valid?
-        return true unless changed?
-
-        res = self.class.transact(tx_data)
-        if dbid.nil?
-          self.dbid = Java::Datomic::Peer.resolve_tempid(
-                                                  res[:"db-after".to_clj],
-                                                  res[:tempids.to_clj],
-                                                  self.class.clj.edn_convert(tempid))
+      module ClassMethods
+        def get(dbid, connection=nil, resolve=false)
+          entity = self.new
+          dbid = dbid.to_i if dbid.is_a?(String)
+          connection ||= Diametric::Persistence::Peer.connect
+          entity = self.from_dbid_or_entity(dbid, connection, resolve)
+          entity
         end
 
-        @previously_changed = changes
-        @changed_attributes.clear
-
-        res
-      end
-
-      def to_edn
-        self.dbid
-      end
+        def q(query, args, conn_or_db=nil)
+          conn_or_db ||= Diametric::Persistence::Peer.connect
+          if conn_or_db.is_a?(Diametric::Persistence::Connection)
+            db = conn_or_db.db
+          else
+            db = conn_or_db
+          end
 
-      def retract_entity(dbid)
-        query = [Java::Datomic::Util.list(":db.fn/retractEntity", dbid)]
-        self.class.connection.transact(query).get
+          results = Diametric::Persistence::Peer.q(query, db, args)
+          # Diametric query expects the first element of each array in
+          # results is dbid. Wraps dbid here by
+          # Diametric::Persistence::Object to make it consistent
+          results.each do |r|
+            r[0] = Diametric::Persistence::Object.new(r[0])
+          end
+          results
+        end
       end
     end
   end

data/lib/diametric/persistence/rest.rb

@@ -47,8 +47,9 @@ module Diametric
           connection.transact(database, data)
         end
 
-        def get(dbid)
-          res = connection.entity(database, dbid)
+        def get(dbid, conn=nil, resolve=false)
+          conn ||= connection
+          res = conn.entity(database, dbid.to_i)
 
           # TODO tighten regex to only allow fields with the model name
           attrs = res.data.map { |attr_symbol, value|
@@ -61,7 +62,7 @@ module Diametric
           entity
         end
 
-        def q(query, args)
+        def q(query, args, unused=nil)
           args.unshift(connection.db_alias(database))
           res = connection.query(query, args)
           res.data

data/lib/diametric/query.rb

@@ -15,16 +15,19 @@ module Diametric
   class Query
     include Enumerable
 
-    attr_reader :conditions, :filters, :model
+    attr_reader :conditions, :filters, :filter_attrs, :model, :connection, :resolve
 
     # Create a new Datomic query.
     #
     # @param model [Entity] This model must include +Datomic::Entity+. Including
     #   a persistence module is optional.
-    def initialize(model)
+    def initialize(model, connection_or_database=nil, resolve=false)
       @model = model
       @conditions = {}
       @filters = []
+      @filter_attrs = []
+      @conn_or_db = connection_or_database
+      @resolve = resolve
     end
 
     # Add conditions to your Datomic query. Conditions check for equality
@@ -69,6 +72,7 @@ module Diametric
     #   that will be converted into a Datalog query.
     # @return [Query]
     def filter(*filter)
+      return peer_filter(filter) if self.model.instance_variable_get("@peer")
       query = self.dup
 
       if filter.first.is_a?(EDN::Type::List)
@@ -82,6 +86,22 @@ module Diametric
       query
     end
 
+    def peer_filter(*filter)
+      query = self.dup
+
+      if filter.first.is_a?(Array)
+        filter = filter.first
+      end
+      filter_attrs << filter[1].to_s
+      filter[1] = "?#{filter[1].to_s}"
+      filter = filter.tap {|e| e.to_s }.join(" ")
+      filter = "[(#{filter})]"
+
+      query.filters << filter
+      query
+    end
+
+
     # Loop through the query results. In order to use +each+, your model *must*
     # include a persistence API. At a minimum, it must have a +.q+ method that
     # returns an +Enumerable+ object.
@@ -90,12 +110,17 @@ module Diametric
     def each
       # TODO check to see if the model has a `.q` method and give
       # an appropriate error if not.
-      res = model.q(*data)
-
+      res = model.q(*data, @conn_or_db)
       collapse_results(res).each do |entity|
+        if self.model.instance_variable_get("@peer") && @resolve
+          yield model.from_dbid_or_entity(entity.first.to_java, @conn_or_db, @resolve)
+        elsif self.model.instance_variable_get("@peer")
+          yield entity.first.to_java
         # The map is for compatibility with Java peer persistence.
         # TODO remove if possible
-        yield model.from_query(entity.map { |x| x })
+        else
+          yield model.from_query(entity.map { |x| x }, @conn_or_db, @resolve)
+        end
       end
     end
 
@@ -113,6 +138,8 @@ module Diametric
     #   is the Datomic query composed of Ruby data. The second element is
     #   the arguments that used with the query.
     def data
+      return peer_data if self.model.instance_variable_get("@peer")
+
       vars = model.attribute_names.map { |attribute| ~"?#{attribute}" }
 
       from = conditions.map { |k, _| ~"?#{k}" }
@@ -133,6 +160,39 @@ module Diametric
       [query, args]
     end
 
+    def peer_data
+      if conditions.empty? && filters.empty?
+        args = [model.prefix]
+        query = <<-EOQ
+[:find ?e
+ :in $ [?include-ns ...]
+ :where
+ [?e ?aid ?v]
+ [?aid :db/ident ?a]
+ [(namespace ?a) ?ns]
+ [(= ?ns ?include-ns)]]
+EOQ
+      else
+        unless conditions.empty?
+          clauses = conditions.keys.inject("") do |memo, attribute|
+            memo + "[?e " + model.namespace(model.prefix, attribute) + " ?#{attribute} ] "
+          end
+          from = conditions.inject("[") {|memo, kv| memo + "?#{kv.shift} "} +"]"
+          args = conditions.map { |_, v| v }
+        end
+
+        unless filter_attrs.empty?
+          clauses ||= ""
+          clauses = filter_attrs.inject(clauses) do |memo, attribute|
+            memo + "[?e " + model.namespace(model.prefix, attribute) + " ?#{attribute} ] "
+          end
+        end
+        query = "[:find ?e :in $ #{from} :where #{clauses} #{filters.join}]"
+      end
+
+      [query, args]
+    end
+
     protected
 
     def conditions=(conditions)
@@ -156,32 +216,43 @@ module Diametric
     end
 
     def collapse_results(res)
+      return res unless @resolve
+
       res.group_by(&:first).map do |dbid, results|
         # extract dbid from results
         # NOTE: we prefer to_a.drop(1) over block arg decomposition because
         #       result may be a Java::ClojureLang::PersistentVector
         results = results.map {|result| result.to_a.drop(1) }
 
-        # Group values from all results into one result set
-        # [["b", 123], ["c", 123]] #=> [["b", "c"], [123, 123]]
-        grouped_values = results.transpose
-
-        # Attach attribute names to each collection of values
-        # => [[:letters, ["b", "c"]], [:number, [123, 123]]]
-        attr_to_values = model.attributes.keys.zip(grouped_values)
-
-        # Retain cardinality/many attributes as a collection,
-        # but pick only one value for cardinality/one attributes
-        collapsed_values = attr_to_values.map do |attr, values|
-          if model.attributes[attr][:cardinality] == :many
-            values
-          else
-            values.first
+        unless results.flatten.empty?
+          # Group values from all results into one result set
+          # [["b", 123], ["c", 123]] #=> [["b", "c"], [123, 123]]
+          grouped_values = results.transpose
+          attr_grouped_values = grouped_values[0...model.attributes.size]
+          enum_grouped_values = grouped_values[model.attributes.size..-1]
+
+          # Attach attribute names to each collection of values
+          # => [[:letters, ["b", "c"]], [:number, [123, 123]]]
+          attr_to_values = model.attributes.keys.zip(attr_grouped_values)
+
+          # Retain cardinality/many attributes as a collection,
+          # but pick only one value for cardinality/one attributes
+          collapsed_values = attr_to_values.map do |attr, values|
+            if model.attributes[attr][:cardinality] == :many
+              values
+            elsif model.attributes[attr][:value_type] == "ref" &&
+                model.enum_names.include?(attr)
+              enum_grouped_values.shift.first
+            else
+              values.first
+            end
           end
-        end
 
-        # Returning a singular result for each dbid
-        [dbid, *collapsed_values]
+          # Returning a singular result for each dbid
+          [dbid, *collapsed_values]
+        else
+          [dbid]
+        end
       end
     end
   end