dalton 0.0.1

data/lib/dalton/attribute.rb

@@ -0,0 +1,16 @@
+module Dalton
+  class Attribute
+    def initialize(datomic_attribute)
+      @datomic_attribute = datomic_attribute
+    end
+
+    def method_missing(name, *args, &block)
+      if @datomic_attribute.respond_to?(name)
+        Translation.from_clj(@datomic_attribute.send(name, *args, &block))
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/dalton/connection.rb

@@ -0,0 +1,104 @@
+java_import "clojure.lang.Keyword"
+java_import "datomic.Peer"
+
+module Dalton
+  class Connection
+
+    include Dalton::Datomization
+
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def self.connect(uri)
+      Peer.createDatabase(uri)
+      database = new(uri)
+      database.connect
+      return database
+    end
+
+    attr_reader :uri, :datomic_connection, :db
+
+    def create
+      Peer.createDatabase(uri) or
+        raise DatomicError, "Unable to create database at \"#{uri}\"."
+    end
+
+    def destroy
+      Peer.deleteDatabase(uri) or
+        raise DatomicError, "Unable to destroy database at \"#{uri}\"."
+    end
+
+    def connect
+      @datomic_connection = Peer.connect(uri) or
+        raise DatomicError, "Unable to connect to database at \"#{uri}\"."
+      refresh
+      true
+    end
+
+    def db=(new_db)
+      @db = new_db.is_a?(Database) ? new_db : Database.new(new_db)
+    end
+
+    def refresh
+      self.db = @datomic_connection.db
+      db
+    end
+
+    def transact(datoms)
+      data = self.class.convert_datoms(datoms)
+      # STDERR.puts "data=#{data.to_edn}"
+      result = TransactionResult.new(@datomic_connection.transact(data).get)
+      self.db = result.db_after
+      Translation.from_clj(result)
+    rescue Java::JavaUtilConcurrent::ExecutionException => e
+      cause = e.getCause
+      if cause.respond_to?(:data)
+        err_data = Translation.from_clj(cause.data)
+        case err_data[:'db/error']
+        when :'db.error/unique-conflict'
+          raise UniqueConflict.parse(cause.getMessage)
+        when :'db.error/wrong-type-for-attribute'
+          raise TypeError.parse(cause.getMessage)
+        end
+      end
+
+      raise DatomicError, "Transaction failed: #{e.getMessage}"
+    end
+
+
+    def retract(entity)
+      entity_id = entity.is_a?(Entity) ? entity.id : entity
+      transact([[:'db.fn/retractEntity', entity_id]])
+    end
+
+    def self.convert_datoms(datoms)
+      case datoms
+        when Array
+          Translation.from_ruby(datoms)
+        when String
+          Utility.read_edn(datoms)
+        else
+          raise ArgumentError, 'datoms must be an Array or a String containing EDN.'
+      end
+    end
+
+    def self.tempid(partition=:'db.part/user', id=nil)
+      partition = Keyword.intern(partition.to_s.sub(/^:/, ''))
+      if id
+        Peer.tempid(partition, id)
+      else
+        Peer.tempid(partition)
+      end
+    end
+
+    def self.tempid?(id)
+      0 > case id
+      when Numeric
+        id
+      when Java::DatomicDb::DbId
+        id.get(Utility::kw('idx'))
+      end
+    end
+  end
+end

data/lib/dalton/database.rb

@@ -0,0 +1,48 @@
+module Dalton
+
+  class Database
+
+    include Dalton::Undatomization
+
+    def initialize(datomic_database_value)
+      @datomic_db = datomic_database_value
+    end
+
+    attr_reader :datomic_db
+
+    def ==(other)
+      datomic_db == other.datomic_db
+    end
+
+    def q(query, *args)
+      translated_query = Translation.from_ruby(query)
+      # STDERR.puts "translated_query=#{translated_query.to_edn}"
+      result = Peer.q(translated_query, datomic_db, *args)
+      Translation.from_clj(result)
+    rescue Java::JavaUtilConcurrent::ExecutionException => e
+      raise DatomicError, "Query failed: #{e.getMessage}"
+    end
+
+    def entity(entity_id)
+      Entity.new(datomic_db.entity(Translation.from_ruby(entity_id)))
+    rescue Java::JavaUtilConcurrent::ExecutionException => e
+      raise DatomicError, "Entity retrieval failed: #{e.getMessage}"
+    end
+
+    def retrieve(query, *inputs)
+      q(query, *inputs).lazy.map { |result| entity(result.first) }
+    end
+
+    def attribute(id)
+      Attribute.new(datomic_db.attribute(Translation.from_ruby(id)))
+    end
+
+    def basis_t
+      datomic_db.basisT
+    end
+
+    def ==(other)
+      self.datomic_db == other.datomic_db
+    end
+  end
+end

data/lib/dalton/datomization.rb

@@ -0,0 +1,18 @@
+module Dalton
+  module Datomization
+
+    Utility.require_clojure('goodguide.datomizer.datomize.setup')
+    Utility.require_clojure('goodguide.datomizer.datomize.decode')
+
+    def set_up_datomizer
+      Utility.run_clojure_function('goodguide.datomizer.datomize.setup/load-datomizer-schema', datomic_connection)
+      Utility.run_clojure_function('goodguide.datomizer.datomize.setup/load-datomizer-functions', datomic_connection)
+    end
+
+    def datomize(data)
+      result = transact([[:'dmzr/datomize', data]])
+      result.resolve_tempid(data[:'db/id'])
+    end
+  end
+
+end

data/lib/dalton/entity.rb

@@ -0,0 +1,75 @@
+module Dalton
+  class Entity
+
+    include Enumerable
+
+    def initialize(datomic_entity)
+      @datomic_entity = datomic_entity
+    end
+
+    attr_reader :datomic_entity
+
+    def db
+      Database.new(datomic_entity.db)
+    end
+
+    def get(key)
+      Translation.from_clj(datomic_entity.get(Translation.from_ruby(key)))
+    end
+
+    alias_method :[], :get
+
+    def touch
+      @datomic_entity.touch
+      self
+    end
+
+    def keys
+      datomic_entity.keySet.map{|x| x.sub(/^:/, '').to_sym}.to_a
+    end
+
+    def id
+      get(:'db/id')
+    end
+
+    def each
+      if block_given?
+        keys.each do |key|
+          yield [key, get(key)]
+        end
+        self
+      else
+        Enumerator.new(self)
+      end
+    end
+    alias_method :each_pair, :each
+
+    def to_h
+      Hash[map {|key, value|
+        [key, decode(value)]
+      }]
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) && Utility.clojure_equal?(datomic_entity, other.datomic_entity)
+    end
+
+    def decode(value)
+      case value
+        when Dalton::Entity
+          value.to_h
+        when Set
+          Set.new(value.map{|x| decode(x)})
+        else
+          Translation.from_clj(value)
+      end
+    end
+
+    DB_FUNCTION_KEY = ::Keyword.intern('db/fn')
+
+    def fn
+      @datomic_entity.get(DB_FUNCTION_KEY)
+    end
+
+  end
+end

data/lib/dalton/exception.rb

@@ -0,0 +1,68 @@
+module Dalton
+  class UniqueConflict < DatomicError
+    # TODO: [jneen] this is terrible, but error handling is not implemented at the moment.
+    # eventually all this data should be accessible via (ex-data e).
+    MESSAGE_RE =
+      %r(^:db[.]error/unique-conflict Unique conflict: :([a-z./-]+), value: (.*?) already held by: (\d+) asserted for: (\d+)$)o
+
+    def self.parse(message)
+      message =~ MESSAGE_RE
+      raise ArgumentError, "invalid format: #{message.inspect}" unless $~
+      new(
+        attribute: $1.to_sym,
+        value: $2,
+        existing_id: Integer($3),
+        new_id: Integer($4),
+      )
+    end
+
+    attr_reader :message, :attribute, :value, :existing_id, :new_id
+
+    def initialize(opts={})
+      @attribute = opts.fetch(:attribute)
+      @value = opts.fetch(:value)
+      @existing_id = opts.fetch(:existing_id)
+      @new_id = opts.fetch(:new_id)
+      @message = "Unique conflict: tried to assign duplicate #@attribute to #@new_id, already held by #@existing_id. value: #@value"
+    end
+
+    def to_s
+      "#{self.class.name}: #@message"
+    end
+
+    def inspect
+      "#<#{self.class.name}: @attribute=#@attribute @value=#@value @existing_id=#@existing_id @new_id=#@new_id>"
+    end
+  end
+
+  class TypeError < DatomicError
+    MESSAGE_RE = %r(^:db[.]error/wrong-type-for-attribute Value (.*?) is not a valid :(\w+) for attribute :([a-z./-]+)$)
+
+    def self.parse(message)
+      message =~ MESSAGE_RE
+      raise ArgumentError, "invalid format: #{message.inspect}" unless $~
+      new(
+        value: $1,
+        type: $2.to_sym,
+        attribute: $3.to_sym
+      )
+    end
+
+    attr_reader :message, :value, :type, :attribute
+
+    def initialize(opts={})
+      @value = opts.fetch(:value)
+      @type = opts.fetch(:type)
+      @attribute = opts.fetch(:attribute)
+      @message = "Type error: tried to set #@attribute as #@value, expected type #@type"
+    end
+
+    def to_s
+      "#{self.class.name}: #@message"
+    end
+
+    def inspect
+      "#<#{self.class.name}: @attribute=#@attribute @value=#@value @type=#@type>"
+    end
+  end
+end

data/lib/dalton/transaction_result.rb

@@ -0,0 +1,33 @@
+java_import "datomic.Peer"
+
+module Dalton
+  class TransactionResult
+    def initialize(result_map)
+      @result_map = result_map
+    end
+
+    def db_before
+      Dalton::Database.new(@result_map.get(Java::Datomic::Connection.DB_BEFORE))
+    end
+
+    def db_after
+      Dalton::Database.new(@result_map.get(Java::Datomic::Connection.DB_AFTER))
+    end
+
+    def tx_data
+      Translation.from_clj(@result_map.get(Java::Datomic::Connection.TX_DATA))
+    end
+
+    def raw_tempids
+      @result_map.get(Java::Datomic::Connection.TEMPIDS)
+    end
+
+    def tempids
+      Translation.from_clj(raw_tempids)
+    end
+
+    def resolve_tempid(tempid)
+      Peer.resolve_tempid(db_after.datomic_db, raw_tempids, tempid)
+    end
+  end
+end

data/lib/dalton/translation.rb

@@ -0,0 +1,65 @@
+java_import "clojure.lang.PersistentHashSet"
+java_import "clojure.lang.Keyword"
+
+module Zweikopf
+  module Primitive
+    def self.is_primitive_type?(obj) # monkey patch to remove DateTime from list of primitives and allow them to be converted. :-/
+      [String, Fixnum, Integer, Float, TrueClass, FalseClass].include?(obj.class)
+    end
+  end
+
+  module Keyword
+    # Monkey patch special handling for datalog variables
+    def self.from_ruby(keyword)
+      if keyword.to_s =~ /^[?$]/
+        Java::ClojureLang::Symbol.intern(keyword.to_s)
+      else
+        ::Keyword.intern(keyword.to_s)
+      end
+    end
+  end
+end
+
+module Dalton
+  module Translation
+
+    module_function
+
+    #TODO: Fork Zweikopf, add Set handling, submit pull request
+
+    def from_clj(object)
+      Zweikopf::Transformer.from_clj(object) do |value|
+        case value
+          when Java::ClojureLang::Symbol
+            value.to_s.to_sym
+          when Java::JavaUtil::Set
+            Set.new(value.map{|x| from_clj(x)})
+          when Java::JavaUtil::ArrayList
+            value.map { |x| from_clj(x) }
+          when Java::Datomic::Entity, Java::DatomicQuery::EntityMap
+            Dalton::Entity.new(value)
+          when Java::JavaUtil::Date
+            Time.at(value.getTime / 1000).to_datetime
+          else
+            value
+        end
+      end
+    end
+
+    def from_ruby(object)
+      Zweikopf::Transformer.from_ruby(object) do |value|
+        case value
+          when ::Set
+            PersistentHashSet.create(value.map{|x| from_ruby(x)})
+          when Dalton::Entity
+            value.datomic_entity
+          when DateTime
+            Java::JavaUtil::Date.new(value.to_time.to_i * 1000)
+          else
+            value
+        end
+      end
+    end
+
+  end
+end

data/lib/dalton/undatomization.rb

@@ -0,0 +1,11 @@
+module Dalton
+
+  module Undatomization
+    def undatomize(id)
+      e = entity(id)
+      clojure_data = Utility.run_clojure_function("goodguide.datomizer.datomize.decode/undatomize", e.datomic_entity)
+      Translation.from_clj(clojure_data)
+    end
+  end
+
+end