dalton 0.0.1

data/lib/dalton/utility.rb

@@ -0,0 +1,91 @@
+java_import "clojure.lang.Keyword"
+java_import "clojure.lang.PersistentArrayMap"
+java_import "clojure.lang.RT"
+
+module Dalton
+  module Utility
+
+    module_function
+
+    def run_clojure_function(namespaced_function, *arguments)
+      namespace, function_name = namespaced_function.to_s.split('/', 2)
+      namespace && function_name or
+        raise ArgumentError, "Namespaced function required. Got: #{namespaced_function.inspect}"
+      RT.var(namespace, function_name).fn.invoke(*arguments)
+    end
+
+    def run_database_function(db, function_ident, *arguments)
+      function_entity = db.entity(Translation.from_ruby(function_ident))
+      function_entity.fn.invoke(*arguments)
+    end
+
+    def require_clojure(namespace)
+      require_function = RT.var("clojure.core", "require").fn
+      require_function.invoke(Java::ClojureLang::Symbol.intern(namespace))
+    end
+
+    require_clojure('datomic.function')
+    require_clojure('datomic.db')
+
+    def read_edn(edn)
+      readers = PersistentArrayMap.create({Keyword.intern('readers') => PersistentArrayMap.create({
+          Java::ClojureLang::Symbol.intern('db/fn') => RT.var('datomic.function', 'construct'),
+          Java::ClojureLang::Symbol.intern('db/id') => RT.var('datomic.db', 'id-literal')
+      })})
+
+      run_clojure_function("clojure.edn/read-string", readers, edn)
+    end
+
+    def rubify_edn(edn)
+      Translation.from_clj(read_edn(edn))
+    end
+
+    def clojure_equal?(one, other)
+      run_clojure_function('clojure.core/=', one, other)
+    end
+
+    def to_edn(clojure_data)
+      run_clojure_function('clojure.core/pr-str', clojure_data)
+    end
+
+    def sym(s)
+      s = s.to_s if s.is_a? Symbol
+      Java::ClojureLang::Symbol.intern(s)
+    end
+
+    def gensym(s)
+      run_clojure_function('clojure.core/gensym', sym(s))
+    end
+
+    def tempid(partition)
+      Peer.tempid(kw(partition))
+    end
+
+    def gensym(s)
+      run_clojure_function('clojure.core/gensym', sym(s))
+    end
+
+    def kw(k)
+      k = k.to_s if k.is_a? Symbol
+      k = k[1..-1] if k.start_with? ':'
+      Java::ClojureLang::Keyword.intern(k)
+    end
+
+    def list(*items)
+      Dalton::Utility.run_clojure_function("clojure.core/list*", items)
+    end
+
+    def with_meta(value, meta)
+      Dalton::Utility.run_clojure_function("clojure.core/with-meta", value, meta)
+    end
+
+    def meta(value)
+      Dalton::Utility.run_clojure_function("clojure.core/meta", value)
+    end
+
+    def tag(value, tag)
+      with_meta(value, Dalton::Translation.from_ruby(tag: tag))
+    end
+  end
+end
+

data/lib/dalton/version.rb

@@ -0,0 +1,3 @@
+module Dalton
+  VERSION = "0.0.1"
+end

data/spec/dalton/connection_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Dalton::Connection do
+  include DatomicContext
+
+  let(:attribute) { :'db/doc' }
+  let(:value) { 'This is a test entity.' }
+
+  let!(:transaction_result) { conn.transact([{:'db/id' => Dalton::Connection.tempid, attribute => value}]) }
+
+  let(:entity_id) { transaction_result.tempids.values.first }
+
+  describe 'data storage, query, and retrieval' do
+
+    let(:query) { [:find, :'?e', :where, [:'?e', attribute, value]] }
+    let(:edn_query) { '[:find ?e :where [?e :db/doc "This is a test entity."]]' }
+
+    describe '#transact(datoms)' do
+
+      it 'stores data' do
+        expect(db.q(query).size).to eq(1)
+      end
+
+      it 'returns a transaction result' do
+        expect(transaction_result.db_before).to be_a(Dalton::Database)
+        expect(transaction_result.db_after).to be_a(Dalton::Database)
+        expect(transaction_result.tx_data).to be_a(Array)
+        expect(transaction_result.tempids).to be_a(Hash)
+      end
+
+      it 'refreshes the database' do
+        expect(conn.db).to eq(transaction_result.db_after)
+      end
+
+      describe 'errors' do
+        before do
+          # create an attribute with :db.unique/value
+          conn.transact([{:'db/id' => Dalton::Connection.tempid(:'db.part/db'),
+                       :'db/ident' => :'user.test/unique-attr',
+                       :'db/cardinality' => :'db.cardinality/one',
+                       :'db/unique' => :'db.unique/value',
+                       :'db/valueType' => :'db.type/string',
+                       :'db.install/_attribute' => :'db.part/db'}])
+
+          tempid = Dalton::Connection.tempid(:'db.part/user')
+          conn.transact([[:'db/add', tempid, :'user.test/unique-attr', 'duplicate-value']])
+        end
+
+        describe 'in uniqueness' do
+          let(:error) {
+            err = nil
+            tempid = Dalton::Connection.tempid(:'db.part/user')
+            begin
+              conn.transact([[:'db/add', tempid, :'user.test/unique-attr', 'duplicate-value']])
+            rescue Dalton::UniqueConflict => e
+              err = e
+            end
+            err
+          }
+
+          it 'contains useful information' do
+            expect(error).to be_a(Dalton::UniqueConflict)
+            expect(error.attribute).to be(:'user.test/unique-attr')
+            expect(error.value).to eql('duplicate-value')
+            expect(error.existing_id).to be > 0
+          end
+        end
+
+        describe 'in type' do
+          let(:error) do
+            err = nil
+            tempid = Dalton::Connection.tempid(:'db.part/user')
+            begin
+              conn.transact([[:'db/add', tempid, :'user.test/unique-attr', 5]])
+            rescue Dalton::TypeError => e
+              err = e
+            end
+            err
+          end
+
+          it 'contains useful information' do
+            expect(error).to be_a(Dalton::TypeError)
+            expect(error.attribute).to be(:'user.test/unique-attr')
+            expect(error.value).to eql('5') # TODO: this sucks, but they're indistinguishable!
+            expect(error.type).to be(:string)
+          end
+        end
+      end
+    end
+
+    describe '#retract(entity)' do
+      shared_examples_for "a retraction" do
+        it 'retracts the entity' do
+          expect(conn.db.q(query).size).to eq(0)
+        end
+      end
+
+      context "when supplied an id" do
+        before do
+          conn.retract(entity_id)
+        end
+
+        it_behaves_like 'a retraction'
+      end
+
+      context "when supplied an entity" do
+        before do
+          conn.retract(conn.db.entity(entity_id))
+        end
+
+        it_behaves_like 'a retraction'
+      end
+    end
+  end
+
+  describe '#tempid?' do
+    subject {Dalton::Connection.tempid?(id)}
+
+    context 'with a temp id' do
+      let (:id) {Dalton::Connection.tempid}
+
+      it { should be true }
+    end
+
+    context 'with a real id' do
+      let (:id) {entity_id}
+
+      it { should be false }
+    end
+  end
+end
+
+

data/spec/dalton/database_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Dalton::Database do
+  include DatomicContext
+
+  describe 'data storage, query, and retrieval' do
+
+    let(:attribute) { :'db/doc' }
+    let(:value) { 'This is a test entity.' }
+
+    let!(:transaction_result) { conn.transact([{:'db/id' => Dalton::Connection.tempid, attribute => value}]) }
+
+    let(:entity_id) { transaction_result.tempids.values.first }
+
+    let(:query) { [:find, :'?e', :where, [:'?e', attribute, value]] }
+    let(:edn_query) { '[:find ?e :where [?e :db/doc "This is a test entity."]]' }
+
+    describe '#q(query)' do
+
+      shared_examples_for 'a query' do
+        it 'runs the query' do
+          expect(query_result).to be_a(Set)
+          expect(query_result.size).to eq(1)
+
+          entity_id = query_result.first.first
+          entity = db.entity(entity_id)
+
+          expect(entity[attribute]).to eq(value)
+        end
+      end
+
+      context "when the query is a ruby data structure" do
+        let(:query_result) { db.q(query) }
+
+        it_behaves_like 'a query'
+      end
+
+      context "when the query is an EDN string" do
+        let(:query_result) { db.q(edn_query) }
+
+        it_behaves_like 'a query'
+      end
+    end
+
+    describe '#entity(entity_id)' do
+      let(:entity) { db.entity(entity_id) }
+
+      it 'fetches an entity from the database' do
+        expect(entity[attribute]).to eq(value)
+      end
+    end
+
+    describe '#retrieve(query)' do
+      let(:results) { db.retrieve(query) }
+      let(:entity) { results.first }
+
+      it 'runs a query and retrieves entities' do
+        expect(results.to_a.size).to eq(1)
+        expect(entity[attribute]).to eq(value)
+      end
+
+      it 'returns a lazy enumerator' do
+        expect(results).to be_a(Enumerator::Lazy)
+      end
+    end
+
+  end
+
+  describe "#attribute" do
+    let(:attribute) { db.attribute(:'db/doc') }
+    it "retrieves an attribute definition" do
+      expect(attribute.hasAVET).to eq(false)
+      expect(attribute.hasFulltext).to eq(true)
+      expect(attribute.hasNoHistory).to eq(false)
+      expect(attribute.id).to be_a(Fixnum)
+      expect(attribute.ident).to eq(:'db/doc')
+      expect(attribute.isComponent).to eq(false)
+      expect(attribute.isIndexed).to eq(false)
+      expect(attribute.unique).to eq(nil)
+      expect(attribute.valueType).to eq(:'db.type/string')
+    end
+  end
+end
+
+

data/spec/dalton/datomization_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Dalton::Datomization do
+  include DatomicContext
+
+  before do
+    conn.set_up_datomizer
+
+    conn.transact([{:'db/id' => Dalton::Connection.tempid(':db.part/db'),
+                 :'db/ident' => :'test/map',
+                 :'db/valueType' => :'db.type/ref',
+                 :'db/cardinality' => :'db.cardinality/many',
+                 :'db/doc' => "A reference attribute for testing datomization",
+                 :'db/isComponent' => true,
+                 :'dmzr.ref/type' => :'dmzr.type/map',
+                 :'db.install/_attribute' => :'db.part/db',
+                },
+                {:'db/id' => Dalton::Connection.tempid(':db.part/db'),
+                 :'db/ident' => :'test/vector',
+                 :'db/valueType' => :'db.type/ref',
+                 :'db/cardinality' => :'db.cardinality/many',
+                 :'db/doc' => "A reference attribute for testing datomization",
+                 :'db/isComponent' => true,
+                 :'dmzr.ref/type' => :'dmzr.type/vector',
+                 :'db.install/_attribute' => :'db.part/db',
+                },
+                {:'db/id' => Dalton::Connection.tempid(':db.part/db'),
+                 :'db/ident' => :'test/edn',
+                 :'db/valueType' => :'db.type/string',
+                 :'db/cardinality' => :'db.cardinality/one',
+                 :'db/doc' => "An EDN string field for edenization testing.",
+                 :'dmzr.ref/type' => :'dmzr.type/edn',
+                 :'db.install/_attribute' => :'db.part/db'}])
+  end
+
+  shared_examples_for "it round trips via datomization" do |attribute|
+    it "should store and retrieve the value" do
+      id = Dalton::Connection.tempid
+      original_data = {:'db/id' => id, attribute => value}
+      real_id = conn.datomize(original_data)
+      round_tripped_data = conn.db.undatomize(real_id)
+      expect(round_tripped_data[attribute]).to eq(value)
+    end
+  end
+
+  context "with an empty map" do
+    let(:value) { {} }
+
+    it_should_behave_like "it round trips via datomization", :'test/map'
+    it_should_behave_like "it round trips via datomization", :'test/edn'
+  end
+
+  context "with a single map element" do
+    let(:value) { {:a => 'grue'} }
+
+    it_should_behave_like "it round trips via datomization", :'test/map'
+    it_should_behave_like "it round trips via datomization", :'test/edn'
+  end
+
+  context "with multiple map elements" do
+    let(:value) { {:a => 'grue', :b => 'wumpus'} }
+
+    it_should_behave_like "it round trips via datomization", :'test/map'
+    it_should_behave_like "it round trips via datomization", :'test/edn'
+  end
+
+  context "with a nested map" do
+    let(:value) { {:a => {:b => 'fnord'}} }
+
+    it_should_behave_like "it round trips via datomization", :'test/map'
+    it_should_behave_like "it round trips via datomization", :'test/edn'
+  end
+
+  context "with an empty array" do
+    let(:value) { [] }
+
+    it_should_behave_like "it round trips via datomization", :'test/vector'
+    it_should_behave_like "it round trips via datomization", :'test/edn'
+  end
+
+  context "with array values" do
+    let(:value) { ['a', 'b', 'c'] }
+
+    it_should_behave_like "it round trips via datomization", :'test/vector'
+    it_should_behave_like "it round trips via datomization", :'test/edn'
+  end
+
+  context "with nested data structure values" do
+    let(:value) { [0, 1, 'a', 'b', 'c', [{:a => {:b => 'fnord'}}, 'x', 'y', 'z']] }
+
+    it_should_behave_like "it round trips via datomization", :'test/vector'
+    it_should_behave_like "it round trips via datomization", :'test/edn'
+  end
+end

data/spec/dalton/entity_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Dalton::Entity do
+  include DatomicContext
+
+  before do
+    conn.transact([{:'db/id' => Dalton::Connection.tempid(':db.part/db'),
+                 :'db/ident' => :'test/stuff',
+                 :'db/valueType' => :'db.type/ref',
+                 :'db/cardinality' => :'db.cardinality/one',
+                 :'db/doc' => 'A reference attribute for testing datomization',
+                 :'db/isComponent' => true,
+                 :'db.install/_attribute' => :'db.part/db',
+                }])
+  end
+
+  describe '#to_h' do
+    let!(:transaction_result) {
+      conn.transact([{:'db/id' => Dalton::Connection.tempid,
+                   :'db/doc' => 'foo',
+                   :'test/stuff' => {:'db/id' => Dalton::Connection.tempid,
+                                     :'db/doc' => 'bar'}}
+                 ])
+
+    }
+    let(:tempids) { transaction_result.tempids.values.sort }
+
+    let(:entity) { conn.db.retrieve([:find, :'?e', :where, [:'?e', :'db/doc', 'foo']]).first }
+    subject { entity.to_h }
+
+    it 'should translate the entity to a hash' do
+      expect(subject).to eq({:'db/doc' => 'foo',
+                             :'test/stuff' =>
+                               {:'db/doc' => 'bar'}})
+    end
+  end
+end