diametric 0.1.1-java

data/lib/diametric/errors.rb

@@ -0,0 +1,13 @@
+require 'diametric'
+
+module Diametric
+  module Errors
+    
+    class ValidationError < StandardError
+      def initialize(entity)
+        super(entity.errors.full_messages.join(", "))
+      end
+    end
+    
+  end
+end

data/lib/diametric/generators/active_model.rb

@@ -0,0 +1,42 @@
+require 'rails/generators/active_model'
+
+module Diametric
+  module Generators
+
+    class ActiveModel < ::Rails::Generators::ActiveModel #:nodoc:
+      def self.all(klass)
+        "#{klass}.all"
+      end
+
+      def self.find(klass, params=nil, connection=nil, resolve=false)
+        "#{klass}.get(#{params}, #{connection}, #{resolve})"
+      end
+
+      def self.build(klass, params=nil)
+        if params
+          "#{klass}.new(#{params})"
+        else
+          "#{klass}.new"
+        end
+      end
+
+      def save
+        "#{name}.save"
+      end
+
+      def update_attributes(params=nil)
+        #"#{name}.update_attributes(#{params})"
+        "#{name}.update(#{params})"
+      end
+
+      def errors
+        "#{name}.errors"
+      end
+
+      def destroy
+        "#{name}.destroy"
+      end
+    end
+
+  end
+end

data/lib/diametric/persistence.rb

@@ -0,0 +1,48 @@
+module Diametric
+  # Persistence is the main entry point for adding persistence to your diametric entities.
+  module Persistence
+    class << self; attr_reader :conn_type; end
+    autoload :REST, 'diametric/persistence/rest'
+
+    # Establish a base connection for your application that is used unless specified otherwise. This method can
+    # establish connections in either REST or peer mode, depending on the supplied options.
+    #
+    # @example Connecting in peer-mode (JRuby required)
+    #   Diametric::Persistence.establish_base_connection({:uri => "datomic:free://localhost:4334/my-db"})
+    #
+    # @example Connecting in REST-mode
+    #   Diametric::Persistence.establish_base_connection({:uri      => "http://localhost:9000/",
+    #                                                     :database => "my-db",
+    #                                                     :storage  => "my-dbalias"})
+    def self.establish_base_connection(options)
+      @_persistence_class = persistence_class(options[:uri])
+      @_persistence_class.connect(options)
+    end
+
+    # Including +Diametric::Persistence+ after establishing a base connection will include
+    # the appropriate Persistence class ({REST} or {Peer})
+    def self.included(base)
+      base.send(:include, @_persistence_class) if @_persistence_class
+    end
+
+    def self.peer?
+      @conn_type == :peer
+    end
+
+    def self.rest?
+      @conn_type == :rest
+    end
+
+    private
+
+    def self.persistence_class(uri)
+      if uri =~ /^datomic:/
+        @conn_type = :peer
+        Peer
+      else
+        @conn_type = :rest
+        REST
+      end
+    end
+  end
+end

data/lib/diametric/persistence/common.rb

@@ -0,0 +1,82 @@
+module Diametric
+  module Persistence
+    module Common
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+        def update_attributes(new_attributes)
+          assign_attributes(new_attributes)
+          save
+        end
+
+        def assign_attributes(new_attributes)
+          valid_keys = attribute_names + [:id]
+          new_attributes.each do |key, value|
+            if valid_keys.include? key.to_sym
+              self.send("#{key}=", value)
+            end
+          end
+        end
+        
+        # Save the entity. If a validation error occurs an error will get raised.
+        #
+        # @example Save the entitiy.
+        #   entity.save!
+        #
+        # @return [ true, false ] True if validation passed.
+        def save!
+          unless save
+            self.class.fail_validate!(self) unless errors.empty?
+          end
+          return true
+        end
+      end
+
+      module ClassMethods
+        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(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 = {}, 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 = {}, 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)
+          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
+    end
+  end
+end

data/lib/diametric/persistence/peer.rb

@@ -0,0 +1,154 @@
+require 'diametric/persistence/common'
+
+module Diametric
+  module Persistence
+    module Peer
+
+      def save(connection=nil)
+        return false unless valid?
+        return true unless changed?
+        connection ||= Diametric::Persistence::Peer.connect
+
+        parsed_data = []
+        parse_tx_data(tx_data, parsed_data)
+
+        map = connection.transact(parsed_data).get
+
+        resolve_changes([self], map)
+
+        map
+      end
+
+      def resolve_tempid(map, id)
+        if id.to_s =~ /-\d+/
+          return Diametric::Persistence::Peer.resolve_tempid(map, id)
+        end
+        return id
+      end
+
+      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 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 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 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
+          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 retract_entity(dbid)
+        Diametric::Persistence::Peer.retract_entity(dbid)
+      end
+
+      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
+
+      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
+
+        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
+
+          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
+end

data/lib/diametric/persistence/rest.rb

@@ -0,0 +1,107 @@
+require 'diametric'
+require 'diametric/persistence/common'
+require 'datomic/client'
+
+# TODO: nice errors when unable to connect
+module Diametric
+  module Persistence
+    module REST
+      @connection = nil
+      @persisted_classes = Set.new
+
+      def self.included(base)
+        base.send(:include, Diametric::Persistence::Common)
+        base.send(:extend, ClassMethods)
+        @persisted_classes.add(base)
+      end
+
+      def self.connection
+        @connection
+      end
+
+      def self.create_schemas
+        @persisted_classes.each do |klass|
+          klass.create_schema
+        end
+      end
+
+      module ClassMethods
+        def connect(options = {})
+          @uri = options[:uri]
+          @dbalias = options[:storage]
+          @database = options[:database]
+
+          @connection = Datomic::Client.new(@uri, @dbalias)
+          @connection.create_database(@database)
+        end
+
+        def connection
+          @connection || Diametric::Persistence::REST.connection
+        end
+
+        def database
+          @database || Diametric::Persistence::REST.database
+        end
+
+        def transact(data)
+          connection.transact(database, data)
+        end
+
+        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|
+            attr = attr_symbol.to_s.gsub(%r"^\w+/", '')
+            [attr, value]
+          }
+
+          entity = self.new(Hash[*attrs.flatten])
+          entity.dbid = dbid
+          entity
+        end
+
+        def q(query, args, unused=nil)
+          args.unshift(connection.db_alias(database))
+          res = connection.query(query, args)
+          res.data
+        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?
+
+        self.dbid = self.dbid.to_i if self.dbid.class == String
+
+        res = self.class.transact(tx_data)
+        if dbid.nil?
+          self.dbid = res.data[:tempids].values.first
+        end
+
+        @previously_changed = changes
+        @changed_attributes.clear
+
+        res
+      end
+
+      def to_edn
+        self.dbid
+      end
+
+      def retract_entity(dbid)
+        query = [[:"db.fn/retractEntity", dbid.to_i]]
+        self.class.transact(query)
+      end
+    end
+  end
+end