dalton 0.0.1

data/spec/dalton/translation_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+java_import "clojure.lang.PersistentHashSet"
+java_import "java.util.HashSet"
+java_import "clojure.lang.Keyword"
+
+describe Dalton::Translation do
+
+  let(:ruby_set) { Set.new([:a, 1, Set.new([:b, 2])]) }
+  let(:clojure_set) {
+    PersistentHashSet.create([Keyword.intern('a'),
+                              1,
+                              PersistentHashSet.create([Keyword.intern('b'),
+                                                        2
+                                                       ])
+                             ])
+  }
+
+  let(:datomic_entity) { Java::DatomicQuery::EntityMap.new(1, 2, 3, 4) }
+  let(:dalton_entity) { Dalton::Entity.new(datomic_entity) }
+
+  let(:ruby_keyword) { :xorn }
+  let(:clojure_keyword) { Keyword.intern('xorn') }
+
+  let(:ruby_keyword_datalog_variable) { :'?e' }
+  let(:clojure_symbol_datalog_variable) { Java::ClojureLang::Symbol.intern('?e') }
+
+  let(:ruby_keyword_datalog_source) { :'$' }
+  let(:clojure_symbol_datalog_source) { Java::ClojureLang::Symbol.intern('$') }
+
+  describe "#from_clj" do
+    context "with a (clojure) IPersistentSet" do
+      subject { Dalton::Translation.from_clj(clojure_set) }
+
+      it 'returns a ruby Set with translated members' do
+        expect(subject).to eq(ruby_set)
+      end
+    end
+
+    context "with a (clojure) Datomic entity" do
+      subject { Dalton::Translation.from_clj(datomic_entity) }
+
+      it 'wraps it in a Dalton entity' do
+        expect(subject).to eq(dalton_entity)
+      end
+    end
+
+    context "with a clojure Keyword" do
+      subject { Dalton::Translation.from_clj(clojure_keyword) }
+
+      it 'returns the equivalent ruby keyword' do
+        expect(subject).to eq(ruby_keyword)
+      end
+    end
+
+    context "with a clojure Symbol" do
+      subject { Dalton::Translation.from_clj(clojure_symbol_datalog_variable) }
+
+      it 'returns the equivalent ruby keyword' do
+        expect(subject).to eq(ruby_keyword_datalog_variable)
+      end
+    end
+
+    context "with a java.util.Date" do
+      subject {
+        format = Java::JavaText::SimpleDateFormat.new("yyyy-MM-dd HH:mm:ss Z")
+        Dalton::Translation.from_clj(format.parse("1998-07-05 07:00:00 -0000"))
+      }
+
+      it 'returns the equivalent ruby DateTime' do
+        expect(subject).to eq(DateTime.parse("1998-07-05 07:00:00 -0000"))
+      end
+    end
+
+  end
+
+  describe "#from_ruby" do
+    context "with a ruby Set" do
+      subject { Dalton::Translation.from_ruby(ruby_set) }
+
+      it 'returns a PersistentHashSet with translated members' do
+        expect(subject).to clojure_equal(clojure_set)
+      end
+    end
+
+    context "with a (ruby) Dalton entity" do
+      subject { Dalton::Translation.from_ruby(dalton_entity) }
+
+      it 'returns the enclosed Datomic entity' do
+        expect(subject).to equal(datomic_entity)
+      end
+    end
+
+    context "with a ruby Keyword starting with '?' (e.g. for use as a datalog variable)" do
+      subject { Dalton::Translation.from_ruby(ruby_keyword_datalog_variable) }
+
+      it 'returns the equivalent clojure symbol' do
+        expect(subject).to clojure_equal(clojure_symbol_datalog_variable)
+      end
+    end
+
+    context "with a ruby Keyword starting with '$' (e.g. for use as a datalog source)" do
+      subject { Dalton::Translation.from_ruby(ruby_keyword_datalog_source) }
+
+      it 'returns the equivalent clojure symbol' do
+        expect(subject).to clojure_equal(clojure_symbol_datalog_source)
+      end
+    end
+
+    context "with a ruby DateTime" do
+      subject {
+        Dalton::Translation.from_ruby(DateTime.parse("1998-07-05 07:00:00 -0000"))
+      }
+
+      let(:expected) {
+        format = Java::JavaText::SimpleDateFormat.new("yyyy-MM-dd HH:mm:ss Z")
+        format.parse("1998-07-05 07:00:00 -0000")
+      }
+
+      it 'returns the equivalent ruby DateTime' do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end
+

data/spec/dalton/utility_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+java_import "clojure.lang.Keyword"
+java_import "clojure.lang.PersistentVector"
+java_import "clojure.lang.IPersistentMap"
+
+describe Dalton::Utility do
+  include Dalton::Utility
+
+  describe '#read_edn' do
+    it 'reads EDN' do
+      read_data = read_edn('[1 2 3]')
+      expected_data = PersistentVector.create([1, 2, 3])
+      expect(read_data).to eq(expected_data)
+    end
+
+    it 'understands tempid literal tags (#db/id)' do
+      tempid = read_edn('#db/id[:db.part/db]')
+      expect(tempid).to be_a(IPersistentMap)
+      expect(tempid[Keyword.intern('part')]).to eq(Keyword.intern('db.part/db'))
+      expect(tempid[Keyword.intern('idx')]).to be_a(Numeric)
+      expect(tempid[Keyword.intern('idx')]).to be < 0
+    end
+
+    it 'understands database function literal tags (#db/fn)' do
+      database_function = read_edn('#db/fn{:lang "clojure" :params [db foo] :code "(reverse foo)"}')
+      expect(database_function).to be_a(IPersistentMap)
+      # with complicated structure we probably don't need to test...
+    end
+  end
+
+  describe "#tag" do
+    it "tag a symbol with metadata" do
+      expect(meta(tag(sym('foo'), sym('String'))).to_edn).to eq('{:tag String}')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'bundler'
+require 'jbundler'
+Bundler.require
+
+require 'wrong/adapters/rspec'
+
+def reload!
+  Object.send(:remove_const, :Dalton) if defined?(Dalton)
+  load './lib/dalton.rb'
+
+  Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each {|f| load(f)}
+
+  true
+end
+
+reload!
+
+RSpec.configure do |config|
+  config.backtrace_exclusion_patterns = []
+  config.backtrace_inclusion_patterns = []
+end

data/spec/support/clojure_equal_matcher.rb

@@ -0,0 +1,52 @@
+require 'rspec/matchers'
+
+module RSpec
+  module Matchers
+    module Dalton
+      class ClojureEqual < BuiltIn::BaseMatcher
+        def match(expected, actual)
+          ::Dalton::Utility.clojure_equal?(actual, expected)
+        end
+
+        def failure_message_for_should
+          return <<-MESSAGE
+
+expected #{inspect_object(expected)}
+     got #{inspect_object(actual)}
+
+Compared using clojure_equal?, which compares using clojure.core/=
+
+MESSAGE
+        end
+
+        def failure_message_for_should_not
+          return <<-MESSAGE
+
+expected not #{inspect_object(actual)}
+         got #{inspect_object(expected)}
+
+Compared using clojure_equal?, which compares using clojure.core/=
+
+MESSAGE
+        end
+
+        def diffable?; true; end
+
+        private
+
+        def inspect_object(o)
+          "#<#{o.class}:#{o.object_id}> => #{o.to_edn}"
+        end
+
+        def eq_expression
+          Expectations::Syntax.positive_expression("actual", "clojure_equal?(expected)")
+        end
+      end
+    end
+
+    def clojure_equal(expected)
+      Dalton::ClojureEqual.new(expected)
+    end
+
+  end
+end

data/spec/support/datomic_context.rb

@@ -0,0 +1,19 @@
+module DatomicContext
+  def self.included(base)
+    base.module_eval do
+      let(:uri) { 'datomic:mem://spec' }
+      # let(:uri) { 'datomic:dev://localhost:4334/spec' }
+      let(:conn) { Dalton::Connection.new(uri) }
+      let(:db) { conn.refresh }
+
+      before do
+        conn.create
+        conn.connect
+      end
+
+      after do
+        conn.destroy
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: dalton
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brian Jenkins
+- Joshua Bates
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zweikopf
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  prerelease: false
+  type: :runtime
+description: Dalton attempts to give low level access to Datomic from JRuby
+email:
+- brian@brianjenkins.org
+- joshua@goodguide.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .jrubyrc
+- .ruby-version
+- Gemfile
+- Jarfile
+- README.md
+- Rakefile
+- dalton.gemspec
+- epl-v10.html
+- examples/posts_controller.rb
+- lib/dalton.rb
+- lib/dalton/attribute.rb
+- lib/dalton/connection.rb
+- lib/dalton/database.rb
+- lib/dalton/datomization.rb
+- lib/dalton/entity.rb
+- lib/dalton/exception.rb
+- lib/dalton/transaction_result.rb
+- lib/dalton/translation.rb
+- lib/dalton/undatomization.rb
+- lib/dalton/utility.rb
+- lib/dalton/version.rb
+- spec/dalton/connection_spec.rb
+- spec/dalton/database_spec.rb
+- spec/dalton/datomization_spec.rb
+- spec/dalton/entity_spec.rb
+- spec/dalton/translation_spec.rb
+- spec/dalton/utility_spec.rb
+- spec/spec_helper.rb
+- spec/support/clojure_equal_matcher.rb
+- spec/support/datomic_context.rb
+homepage: ''
+licenses:
+- EPL
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: A thin Datomic driver for JRuby
+test_files:
+- spec/dalton/connection_spec.rb
+- spec/dalton/database_spec.rb
+- spec/dalton/datomization_spec.rb
+- spec/dalton/entity_spec.rb
+- spec/dalton/translation_spec.rb
+- spec/dalton/utility_spec.rb
+- spec/spec_helper.rb
+- spec/support/clojure_equal_matcher.rb
+- spec/support/datomic_context.rb
+has_rdoc: