diametric 0.0.1

data/lib/diametric/persistence/rest.rb

@@ -0,0 +1,88 @@
+require 'diametric'
+require 'diametric/persistence/common'
+require 'datomic/client'
+
+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(uri, dbalias, database)
+          @uri = uri
+          @dbalias = dbalias
+          @database = 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)
+          res = connection.entity(database, dbid)
+
+          # 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)
+          args.unshift(connection.db_alias(database))
+          res = connection.query(query, args)
+          res.data
+        end
+      end
+
+      extend ClassMethods
+
+      def save
+        return false unless valid?
+        return true unless changed?
+
+        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
+    end
+  end
+end

data/lib/diametric/query.rb

@@ -0,0 +1,157 @@
+require 'diametric'
+
+module Diametric
+  # +Query+ objects are used to generate Datomic queries, whether to
+  # send via an external client or via the persistence API. The two
+  # methods used to generate a query are +.where+ and +.filter+, both
+  # of which are chainable. To get the query data and arguments for a
+  # +Query+, use the +data+ method.
+  #
+  # If you are using a persistence API, you can ask +Query+ to get the
+  # results of a Datomic query. +Diametric::Query+ is an
+  # +Enumerable+. To get the results of a query, use +Enumerable+
+  # methods such as +.each+ or +.first+. +Query+ also provides a
+  # +.all+ method to run the query and get the results.
+  class Query
+    include Enumerable
+
+    attr_reader :conditions, :filters, :model
+
+    # Create a new Datomic query.
+    #
+    # @param model [Entity] This model must include +Datomic::Entity+. Including
+    #   a persistence module is optional.
+    def initialize(model)
+      @model = model
+      @conditions = {}
+      @filters = []
+    end
+
+    # Add conditions to your Datomic query. Conditions check for equality
+    # against entity attributes. In addition, you can add conditions for
+    # use as variables in filters.
+    #
+    # @example Looking for mice named Wilbur.
+    #   Query.new(Mouse).conditions(:name => "Wilbur")
+    #
+    # @param conditions [Hash] Datomic variables and values.
+    # @return [Query]
+    def where(conditions)
+      query = self.dup
+      query.conditions = query.conditions.merge(conditions)
+      query
+    end
+
+    # Add a filter to your Datomic query. Filters are known as expression clause
+    # predicates in the {Datomic query documentation}[http://docs.datomic.com/query.html].
+    #
+    # A filter can be in one of two forms. In the first, you pass a
+    # series of arguments. Any Ruby symbol given in this form will be
+    # converted to a EDN symbol. If the symbol is the same as one of
+    # the queried model's attributes or as a key passed to +where+, it
+    # will be prefixed with a +?+ so that it becomes a Datalog
+    # variable. In the second form, you pass
+    # {EDN}[https://github.com/relevance/edn-ruby] representing a
+    # Datomic predicate to +filter+. No conversion is done on this
+    # filter and it must be an EDN list.
+    #
+    # @example Passing arguments to be converted.
+    #   query.filter(:>, :age, 21)
+    #
+    # @example Passing EDN, which will not be converted.
+    #   query.filter(EDN::Type::List.new(EDN::Type::Symbol(">"),
+    #                                    EDN::Type::Symbol("?age"),
+    #                                    21))
+    #   # or, more simply
+    #   query.filter(~[~">", ~"?age", 21])
+    #
+    # @param filter [Array] Either one +EDN::Type::List+ or a number of arguments
+    #   that will be converted into a Datalog query.
+    # @return [Query]
+    def filter(*filter)
+      query = self.dup
+
+      if filter.first.is_a?(EDN::Type::List)
+        filter = filter.first
+      else
+        filter = filter.map { |e| convert_filter_element(e) }
+        filter = EDN::Type::List.new(*filter)
+      end
+
+      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.
+    #
+    # @yield [Entity] An instance of the model passed to +Query+.
+    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.each do |entity|
+        # The map is for compatibility with Java peer persistence.
+        # TODO remove if possible
+        yield model.from_query(entity.map { |x| x })
+      end
+    end
+
+    # Return all query results.
+    #
+    # @return [Array<Entity>] Query results.
+    def all
+      map { |x| x }
+    end
+
+    # Create a Datomic query from the conditions and filters passed to this
+    # +Query+ object.
+    #
+    # @return [Array(Array, Array)] The first element of the array returned
+    #   is the Datomic query composed of Ruby data. The second element is
+    #   the arguments that used with the query.
+    def data
+      vars = model.attributes.map { |attribute, _, _| ~"?#{attribute}" }
+
+      from = conditions.map { |k, _| ~"?#{k}" }
+
+      clauses = model.attributes.map { |attribute, _, _|
+        [~"?e", model.namespace(model.prefix, attribute), ~"?#{attribute}"]
+      }
+      clauses += filters
+
+      args = conditions.map { |_, v| v }
+
+      query = [
+        :find, ~"?e", *vars,
+        :in, ~"\$", *from,
+        :where, *clauses
+      ]
+
+      [query, args]
+    end
+
+    protected
+
+    def conditions=(conditions)
+      @conditions = conditions
+    end
+
+    def filters=(filters)
+      @filters = filters
+    end
+
+    def convert_filter_element(element)
+      if element.is_a?(Symbol)
+        if model.attribute_names.include?(element) || @conditions.keys.include?(element)
+          EDN::Type::Symbol.new("?#{element}")
+        else
+          EDN::Type::Symbol.new(element.to_s)
+        end
+      else
+        element
+      end
+    end
+  end
+end

data/lib/diametric/version.rb

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

data/lib/jrclj.rb

@@ -0,0 +1,63 @@
+require 'java'
+
+java_import "clojure.lang.RT"
+
+class JRClj
+  def initialize *pkgs
+    @mappings = {}
+    @ns_map  = RT.var "clojure.core", "ns-map"
+    @symbol  = RT.var "clojure.core", "symbol"
+    @require = RT.var "clojure.core", "require"
+    _import "clojure.core"
+    pkgs.each do |pkg|
+      _import pkg
+    end
+  end
+
+  def _import pkg_name, sym=nil, sym_alias=nil
+    @require.invoke @symbol.invoke(pkg_name)
+    if sym
+      sym_alias ||= sym
+      @mappings[sym_alias] = RT.var pkg_name, sym
+      return
+    end
+    pkg = @symbol.invoke pkg_name
+    @ns_map.invoke(pkg).each do |sym,var|
+      @mappings[sym.to_s] = var
+    end
+  end
+
+  def _eval s
+    self.eval self.read_string(s)
+  end
+
+  def _invoke m, *args
+    fun = @mappings[m.to_s] || @mappings[m.to_s.gsub "_", "-"]
+    unless fun
+      raise "Error, no current binding for symbol=#{m}"
+    end
+    fun.invoke(*args)
+  end
+
+  def _alias new, old
+    @mappings[new] = @mappings[old]
+  end
+
+  def method_missing symbol, *args
+    _invoke symbol, *args
+  end
+
+  def self.persistent_map entries=[]
+    Java::ClojureLang::PersistentArrayMap.new entries.to_java
+  end
+
+  def edn_convert(obj)
+    self.read_string(obj.to_edn)
+  end
+end
+
+class Symbol
+  def to_clj
+    Java::ClojureLang::Keyword.intern(self.to_s)
+  end
+end

data/spec/diametric/entity_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Diametric::Entity do
+  describe "in a class" do
+    subject { Person }
+
+    it { should respond_to(:attribute) }
+    it { should respond_to(:schema) }
+    it { should respond_to(:from_query) }
+
+    it "should generate a schema" do
+      Person.schema.should == [
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/name",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/index" => true,
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/email",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/many",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/birthday",
+          :"db/valueType" => :"db.type/instant",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/awesome",
+          :"db/valueType" => :"db.type/boolean",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/doc" => "Is this person awesome?",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/ssn",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/unique" => :"db.unique/value",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/secret_name",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/unique" => :"db.unique/identity",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/bio",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/fulltext" => true,
+          :"db.install/_attribute" => :"db.part/db" }
+      ]
+    end
+  end
+
+  describe "in an instance" do
+    subject { Person.new }
+    let(:model) { Person.new }
+
+    it_should_behave_like "ActiveModel"
+
+    it { should respond_to(:tx_data) }
+
+    it "should handle attributes correctly" do
+      subject.name.should be_nil
+      subject.name = "Clinton"
+      subject.name.should == "Clinton"
+    end
+  end
+
+  describe ".new" do
+    it "should work without arguments" do
+      Person.new.should be_a(Person)
+    end
+
+    it "should assign attributes based off argument keys" do
+      person = Person.new(:name => "Dashiell D", :secret_name => "Monito")
+      person.name.should == "Dashiell D"
+      person.secret_name.should == "Monito"
+    end
+  end
+
+  describe ".from_query" do
+    it "should assign dbid and attributes" do
+      goat = Goat.from_query([1, "Beans", DateTime.parse("1976/9/4")])
+      goat.dbid.should == 1
+      goat.name.should == "Beans"
+      goat.birthday.should == DateTime.parse("1976/9/4")
+    end
+  end
+
+  describe "#tx_data" do
+    let(:goat) { Goat.new(:name => "Beans", :birthday => Date.parse("2002-04-15"))}
+
+    describe "without a dbid" do
+      it "should generate a transaction with a new tempid" do
+        # Equivalence is currently wrong on EDN tagged values.
+        tx = goat.tx_data.first
+        tx.keys.should == [:"db/id", :"goat/name", :"goat/birthday"]
+        tx[:"db/id"].to_edn.should match(%r"#db/id \[:db.part/user \-\d+\]")
+        tx[:"goat/name"].should == "Beans"
+        tx[:"goat/birthday"].should == goat.birthday
+      end
+    end
+
+    describe "with a dbid" do
+      it "should generate a transaction with the dbid" do
+        goat.dbid = 1
+        goat.tx_data.should == [
+          { :"db/id" => 1,
+            :"goat/name" => "Beans",
+            :"goat/birthday" => goat.birthday
+          }
+        ]
+      end
+
+      it "should generate a transaction with only specified attributes" do
+        goat.dbid = 1
+        goat.tx_data(:name).should == [
+          { :"db/id" => 1,
+            :"goat/name" => "Beans"
+          }
+        ]
+      end
+    end
+  end
+end

data/spec/diametric/persistence/peer_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'diametric/persistence/peer' if RUBY_ENGINE == 'jruby'
+
+# Prevent CRuby from blowing up
+module Diametric
+  module Persistence
+    module Peer
+    end
+  end
+end
+
+describe Diametric::Persistence::Peer, :jruby do
+  class Rat
+    include Diametric::Entity
+    include Diametric::Persistence::Peer
+
+    attribute :name, String, :index => true
+    attribute :age, Integer
+  end
+
+  let(:db_uri) { 'datomic:mem://hello' }
+
+  it "can connect to a Datomic database" do
+    subject.connect(db_uri)
+    subject.connection.should be_a(Java::DatomicPeer::LocalConnection)
+  end
+
+  it_behaves_like "persistence API" do
+    let(:model_class) { Rat }
+
+    before(:all) do
+      subject.connect(db_uri)
+      Diametric::Persistence::Peer.create_schemas
+    end
+  end
+end