diametric 0.0.1

data/diametric.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'diametric/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "diametric"
+  gem.version       = Diametric::VERSION
+  gem.authors       = ["Clinton N. Dreisbach"]
+  gem.email         = ["crnixon@gmail.com"]
+  gem.summary       = %q{ActiveModel for Datomic}
+  gem.description   = <<EOF
+Diametric is a library for building schemas, queries, and transactions
+for Datomic from Ruby objects. It is also used to map Ruby objects
+as entities into a Datomic database.
+EOF
+  gem.homepage      = "https://github.com/crnixon/diametric"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'edn', '~> 1.0'
+  gem.add_dependency 'activesupport', '>= 3.0.0'
+  gem.add_dependency 'activemodel', '>= 3.0.0'
+  gem.add_dependency 'datomic-client', '~> 0.4.1'
+  gem.add_dependency 'lock_jar', '~> 0.7.2'
+
+  gem.extensions = ['Rakefile']
+end

data/lib/diametric.rb

@@ -0,0 +1,9 @@
+require "diametric/version"
+require "diametric/entity"
+require "diametric/query"
+
+# Diametric is a library for building schemas, queries, and
+# transactions for Datomic from Ruby objects. It is also used to map
+# Ruby objects as entities into a Datomic database.
+module Diametric
+end

data/lib/diametric/entity.rb

@@ -0,0 +1,339 @@
+require "bigdecimal"
+require "edn"
+require 'active_support/core_ext'
+require 'active_support/inflector'
+require 'active_model'
+
+module Diametric
+
+  # +Diametric::Entity+ is a module that, when included in a class,
+  # gives it the ability to generate Datomic schemas, queries, and
+  # transactions, and makes it +ActiveModel+ compliant.
+  #
+  # While this allows you to use this anywhere you would use an
+  # +ActiveRecord::Base+ model or another +ActiveModel+-compliant
+  # instance, it _does not_ include persistence. The +Entity+ module
+  # is primarily made of pure functions that take their receiver (an
+  # instance of the class they are included in) and return data that
+  # you can use in Datomic. +Entity+ can be best thought of as a data
+  # builder for Datomic.
+  #
+  # Of course, you can combine +Entity+ with one of the two available
+  # Diametric persistence modules for a fully persistent model.
+  #
+  # When +Entity+ is included in a class, that class is extended with
+  # {ClassMethods}.
+  #
+  # @!attribute dbid
+  #   The database id assigned to the entity by Datomic.
+  #   @return [Integer]
+  module Entity
+    # Conversions from Ruby types to Datomic types.
+    VALUE_TYPES = {
+      Symbol => "keyword",
+      String => "string",
+      Integer => "long",
+      Float => "float",
+      BigDecimal => "bigdec",
+      DateTime => "instant",
+      URI => "uri"
+    }
+
+    @temp_ref = -1000
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+      base.send(:extend, ActiveModel::Naming)
+      base.send(:include, ActiveModel::Conversion)
+      base.send(:include, ActiveModel::Dirty)
+
+      base.class_eval do
+        @attributes = []
+        @partition = :"db.part/user"
+      end
+    end
+
+    def self.next_temp_ref
+      @temp_ref -= 1
+    end
+
+    # @!attribute [rw] partition
+    #   The Datomic partition this entity's data will be stored in.
+    #   Defaults to +:db.part/user+.
+    #   @return [String]
+    #
+    # @!attribute [r] attributes
+    #   @return [Array] Definitions of each of the entity's attributes (name, type, options).
+    module ClassMethods
+      def partition
+        @partition
+      end
+
+      def partition=(partition)
+        self.partition = partition.to_sym
+      end
+
+      def attributes
+        @attributes
+      end
+
+      # Add an attribute to a {Diametric::Entity}.
+      #
+      # Valid options are:
+      #
+      # * +:index+: The only valid value is +true+. This causes the
+      #   attribute to be indexed for easier lookup.
+      # * +:unique+: Valid values are +:value+ or +:identity.
+      #   * +:value+ causes the attribute value to be unique to the
+      #     entity and attempts to insert a duplicate value will fail.
+      #   * +:identity+ causes the attribute value to be unique to
+      #     the entity. Attempts to insert a duplicate value with a
+      #     temporary entity id will result in an "upsert," causing the
+      #     temporary entity's attributes to be merged with those for
+      #     the current entity in Datomic.
+      # * +:cardinality+: Specifies whether an attribute associates
+      #   a single value or a set of values with an entity. The
+      #   values allowed are:
+      #   * +:one+ - the attribute is single valued, it associates a
+      #     single value with an entity.
+      #   * +:many+ - the attribute is mutli valued, it associates a
+      #     set of values with an entity.
+      #   To be honest, I have no idea how this will work in Ruby. Try +:many+ at your own risk.
+      #   +:one+ is the default.
+      # * +:doc+: A string used in Datomic to document the attribute.
+      # * +:fulltext+: The only valid value is +true+. Indicates that a
+      #   fulltext search index should be generated for the attribute.
+      #
+      # @example Add an indexed name attribute.
+      #   attribute :name, String, :index => true
+      #
+      # @param name [String] The attribute's name.
+      # @param value_type [Class] The attribute's type.
+      #   Must exist in {Diametric::Entity::VALUE_TYPES}.
+      # @param opts [Hash] Options to pass to Datomic.
+      #
+      # @return void
+      def attribute(name, value_type, opts = {})
+        @attributes << [name, value_type, opts]
+        define_attribute_method name
+        define_method(name) do
+          instance_variable_get("@#{name}")
+        end
+        define_method("#{name}=") do |value|
+          send("#{name}_will_change!") unless value == instance_variable_get("@#{name}")
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      # @return [Array<Symbol>] Names of the entity's attributes.
+      def attribute_names
+        @attributes.map { |name, _, _| name }
+      end
+
+      # Generates a Datomic schema for a model's attributes.
+      #
+      # @return [Array] A Datomic schema, as Ruby data that can be
+      #   converted to EDN.
+      def schema
+        defaults = {
+          :"db/id" => tempid(:"db.part/db"),
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db.install/_attribute" => :"db.part/db"
+        }
+
+        @attributes.reduce([]) do |schema, (attribute, value_type, opts)|
+          opts = opts.dup
+          unless opts.empty?
+            opts[:cardinality] = namespace("db.cardinality", opts[:cardinality]) if opts[:cardinality]
+            opts[:unique] = namespace("db.unique", opts[:unique]) if opts[:unique]
+            opts = opts.map { |k, v|
+              k = namespace("db", k)
+              [k, v]
+            }
+            opts = Hash[*opts.flatten]
+          end
+
+          schema << defaults.merge({
+                                     :"db/ident" => namespace(prefix, attribute),
+                                     :"db/valueType" => value_type(value_type),
+                                   }).merge(opts)
+        end
+      end
+
+      # Given a set of Ruby data returned from a Datomic query, this
+      # can re-hydrate that data into a model instance.
+      #
+      # @return [Entity]
+      def from_query(query_results)
+        dbid = query_results.shift
+        widget = self.new(Hash[*(@attributes.map { |attribute, _, _| attribute }.zip(query_results).flatten)])
+        widget.dbid = dbid
+        widget
+      end
+
+      # Returns the prefix for this model used in Datomic.
+      #
+      # @example
+      #   Mouse.prefix #=> "mouse"
+      #   FireHouse.prefix #=> "fire_house"
+      #   Person::User.prefix #=> "person.user"
+      #
+      # @return [String]
+      def prefix
+        self.to_s.underscore.sub('/', '.')
+      end
+
+      # Create a temporary id placeholder.
+      #
+      # @param e [*#to_edn] Elements to put in the placeholder. Should
+      #   be either partition or partition and a negative number to be
+      #   used as a reference.
+      #
+      # @return [EDN::Type::Unknown] Temporary id placeholder.
+      def tempid(*e)
+        EDN.tagged_element('db/id', e)
+      end
+
+      # Namespace a attribute for Datomic.
+      #
+      # @param ns [#to_s] Namespace.
+      # @param attribute [#to_s] Attribute.
+      #
+      # @return [Symbol] Namespaced attribute.
+      def namespace(ns, attribute)
+        [ns.to_s, attribute.to_s].join("/").to_sym
+      end
+
+      private
+
+      def value_type(vt)
+        if vt.is_a?(Class)
+          vt = VALUE_TYPES[vt]
+        end
+        namespace("db.type", vt)
+      end
+    end
+
+    def dbid
+      @dbid
+    end
+
+    def dbid=(dbid)
+      @dbid = dbid
+    end
+
+    alias :id :dbid
+    alias :"id=" :"dbid="
+
+    # Create a new {Diametric::Entity}.
+    #
+    # @param params [Hash] A hash of attributes and values to
+    #   initialize the entity with.
+    def initialize(params = {})
+      params.each do |k, v|
+        self.send("#{k}=", v)
+      end
+    end
+
+    # @return [Integer] A reference unique to this entity instance
+    #   used in constructing temporary ids for transactions.
+    def temp_ref
+      @temp_ref ||= Diametric::Entity.next_temp_ref
+    end
+
+    # Creates data for a Datomic transaction.
+    #
+    # @param attributes [*Symbol] Attributes to save in the
+    #   transaction. If no attributes are given, any changed
+    #   attributes will be saved.
+    #
+    # @return [Array] Datomic transaction data.
+    def tx_data(*attributes)
+      tx = {:"db/id" => dbid || tempid}
+      attributes = self.changed_attributes.keys if attributes.empty?
+      attributes.reduce(tx) do |t, attribute|
+        t[self.class.namespace(self.class.prefix, attribute)] = self.send(attribute)
+        t
+      end
+      [tx]
+    end
+
+    # @return [Array<Symbol>] Names of the entity's attributes.
+    def attribute_names
+      self.class.attribute_names
+    end
+
+    # @return [EDN::Type::Unknown] A temporary id placeholder for
+    #   use in transactions.
+    def tempid
+      self.class.tempid(self.class.partition, temp_ref)
+    end
+
+    # Checks to see if the two objects are the same entity in Datomic.
+    #
+    # @return [Boolean]
+    def ==(other)
+      return false if self.dbid.nil?
+      return false unless other.respond_to?(:dbid)
+      return false unless self.dbid == other.dbid
+      true
+    end
+
+    # Checks to see if the two objects are of the same type, are the same
+    # entity, and have the same attribute values.
+    #
+    # @return [Boolean]
+    def eql?(other)
+      return false unless self == other
+      return false unless self.class == other.class
+
+      attribute_names.each do |attr|
+        return false unless self.send(attr) == other.send(attr)
+      end
+
+      true
+    end
+
+    # Methods for ActiveModel compliance.
+
+    # For ActiveModel compliance.
+    # @return [self]
+    def to_model
+      self
+    end
+
+    # Key for use in REST URL's, etc.
+    # @return [Integer, nil]
+    def to_key
+      persisted? ? [dbid] : nil
+    end
+
+    # @return [Boolean] Is the entity persisted?
+    def persisted?
+      !dbid.nil?
+    end
+
+    # @return [Boolean] Is this a new entity (that is, not persisted)?
+    def new_record?
+      !persisted?
+    end
+
+    # @return [false] Is this entity destroyed? (Always false.) For
+    #   ActiveModel compliance.
+    def destroyed?
+      false
+    end
+
+    # @return [Boolean] Is this entity valid? By default, this is
+    #   always true.
+    def valid?
+      errors.empty?
+    end
+
+    # @return [ActiveModel::Errors] Errors on this entity. By default,
+    #   this is empty.
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+  end
+end

data/lib/diametric/persistence/common.rb

@@ -0,0 +1,29 @@
+module Diametric
+  module Persistence
+    module Common
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      end
+
+      module ClassMethods
+        def create_schema
+          transact(schema)
+        end
+
+        def first(conditions = {})
+          where(conditions).first
+        end
+
+        def where(conditions = {})
+          query = Diametric::Query.new(self)
+          query.where(conditions)
+        end
+
+        def filter(*filter)
+          query = Diametric::Query.new(self)
+          query.filter(*filter)
+        end
+      end
+    end
+  end
+end

data/lib/diametric/persistence/peer.rb

@@ -0,0 +1,107 @@
+unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  raise "This module requires the use of JRuby."
+end
+
+require 'diametric'
+require 'diametric/persistence/common'
+
+require 'java'
+require 'lock_jar'
+lockfile = File.expand_path( "../../../../Jarfile.lock", __FILE__ )
+# Loads the classpath with Jars from the lockfile
+LockJar.load(lockfile)
+
+require 'jrclj'
+java_import "clojure.lang.Keyword"
+
+module Diametric
+  module Persistence
+    module Peer
+      include_package "datomic"
+
+      @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
+        include_package "datomic"
+
+        def connect(uri)
+          Java::Datomic::Peer.create_database(uri)
+          @connection = Java::Datomic::Peer.connect(uri)
+        end
+
+        def disconnect
+          @connection = nil
+        end
+
+        def connection
+          @connection || Diametric::Persistence::Peer.connection
+        end
+
+        def transact(data)
+          data = clj.edn_convert(data)
+          res = connection.transact(data)
+          res.get
+        end
+
+        def get(dbid)
+          entity_map = connection.db.entity(dbid)
+          attrs = entity_map.key_set.map { |attr_keyword|
+            attr = attr_keyword.to_s.gsub(%r"^:\w+/", '')
+            value = entity_map.get(attr_keyword)
+            [attr, value]
+          }
+
+          entity = self.new(Hash[*attrs.flatten])
+          entity.dbid = dbid
+
+          entity
+        end
+
+        def q(query, args)
+          Java::Datomic::Peer.q(clj.edn_convert(query), connection.db, *args)
+        end
+
+        def clj
+          @clj ||= JRClj.new
+        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 = Java::Datomic::Peer.resolve_tempid(
+                                                  res[:"db-after".to_clj],
+                                                  res[:tempids.to_clj],
+                                                  self.class.clj.edn_convert(tempid))
+        end
+
+        @previously_changed = changes
+        @changed_attributes.clear
+
+        res
+      end
+    end
+  end
+end