diametric 0.0.1 → 0.0.2

data/lib/diametric/generators/active_model.rb

@@ -0,0 +1,42 @@
+require 'rails/generators/active_model'
+
+module Diametric
+  module Generators
+
+    class ActiveModel < ::Rails::Generators::ActiveModel #:nodoc:
+      def self.all(klass)
+        "#{klass}.all"
+      end
+
+      def self.find(klass, params=nil)
+        "#{klass}.get(#{params})"
+      end
+
+      def self.build(klass, params=nil)
+        if params
+          "#{klass}.new(#{params})"
+        else
+          "#{klass}.new"
+        end
+      end
+
+      def save
+        "#{name}.save"
+      end
+
+      def update_attributes(params=nil)
+        #"#{name}.update_attributes(#{params})"
+        "#{name}.update(#{params})"
+      end
+
+      def errors
+        "#{name}.errors"
+      end
+
+      def destroy
+        "#{name}.destroy"
+      end
+    end
+
+  end
+end

data/lib/diametric/persistence.rb

@@ -0,0 +1,49 @@
+module Diametric
+  # Persistence is the main entry point for adding persistence to your diametric entities.
+  module Persistence
+    class << self; attr_reader :conn_type; end
+    autoload :REST, 'diametric/persistence/rest'
+
+    # Establish a base connection for your application that is used unless specified otherwise. This method can
+    # establish connections in either REST or peer mode, depending on the supplied options.
+    #
+    # @example Connecting in peer-mode (JRuby required)
+    #   Diametric::Persistence.establish_base_connection({:uri => "datomic:free://localhost:4334/my-db"})
+    #
+    # @example Connecting in REST-mode
+    #   Diametric::Persistence.establish_base_connection({:uri      => "http://localhost:9000/",
+    #                                                     :database => "my-db",
+    #                                                     :storage  => "my-dbalias"})
+    def self.establish_base_connection(options)
+      @_persistence_class = persistence_class(options[:uri])
+      @_persistence_class.connect(options)
+    end
+
+    # Including +Diametric::Persistence+ after establishing a base connection will include
+    # the appropriate Persistence class ({REST} or {Peer})
+    def self.included(base)
+      base.send(:include, @_persistence_class) if @_persistence_class
+    end
+
+    def self.peer?
+      @conn_type == :peer
+    end
+
+    def self.rest?
+      @conn_type == :rest
+    end
+
+    private
+
+    def self.persistence_class(uri)
+      if uri =~ /^datomic:/
+        require 'diametric/persistence/peer'
+        @conn_type = :peer
+        Peer
+      else
+        @conn_type = :rest
+        REST
+      end
+    end
+  end
+end

data/lib/diametric/persistence/common.rb

@@ -3,6 +3,23 @@ module Diametric
     module Common
       def self.included(base)
         base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+        def update_attributes(new_attributes)
+          assign_attributes(new_attributes)
+          save
+        end
+
+        def assign_attributes(new_attributes)
+          valid_keys = attribute_names + [:id]
+          new_attributes.each do |key, value|
+            if valid_keys.include? key.to_sym
+              self.send("#{key}=", value)
+            end
+          end
+        end
       end
 
       module ClassMethods
@@ -10,6 +27,10 @@ module Diametric
           transact(schema)
         end
 
+        def all
+          Diametric::Query.new(self).all
+        end
+
         def first(conditions = {})
           where(conditions).first
         end

data/lib/diametric/persistence/peer.rb

@@ -41,7 +41,8 @@ module Diametric
       module ClassMethods
         include_package "datomic"
 
-        def connect(uri)
+        def connect(options = {})
+          uri = options[:uri]
           Java::Datomic::Peer.create_database(uri)
           @connection = Java::Datomic::Peer.connect(uri)
         end
@@ -61,16 +62,12 @@ module Diametric
         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 = self.new
+          self.all.each do |e|
+            next unless e.dbid == dbid.to_i
+            e.attribute_names.each {|n| entity.send((n.to_s+"=").to_sym, e.send(n))}
+          end
+          entity.dbid = dbid.to_i
           entity
         end
 
@@ -102,6 +99,15 @@ module Diametric
 
         res
       end
+
+      def to_edn
+        self.dbid
+      end
+
+      def retract_entity(dbid)
+        query = [Java::Datomic::Util.list(":db.fn/retractEntity", dbid)]
+        self.class.connection.transact(query).get
+      end
     end
   end
 end

data/lib/diametric/persistence/rest.rb

@@ -2,6 +2,7 @@ require 'diametric'
 require 'diametric/persistence/common'
 require 'datomic/client'
 
+# TODO: nice errors when unable to connect
 module Diametric
   module Persistence
     module REST
@@ -25,13 +26,13 @@ module Diametric
       end
 
       module ClassMethods
-        def connect(uri, dbalias, database)
-          @uri = uri
-          @dbalias = dbalias
-          @database = database
+        def connect(options = {})
+          @uri = options[:uri]
+          @dbalias = options[:storage]
+          @database = options[:database]
 
-          @connection = Datomic::Client.new(uri, dbalias)
-          @connection.create_database(database)
+          @connection = Datomic::Client.new(@uri, @dbalias)
+          @connection.create_database(@database)
         end
 
         def connection
@@ -73,6 +74,8 @@ module Diametric
         return false unless valid?
         return true unless changed?
 
+        self.dbid = self.dbid.to_i if self.dbid.class == String
+
         res = self.class.transact(tx_data)
         if dbid.nil?
           self.dbid = res.data[:tempids].values.first
@@ -83,6 +86,11 @@ module Diametric
 
         res
       end
+
+      def retract_entity(dbid)
+        query = [[:"db.fn/retractEntity", dbid.to_i]]
+        self.class.transact(query)
+      end
     end
   end
 end

data/lib/diametric/query.rb

@@ -91,7 +91,8 @@ module Diametric
       # 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|
+
+      collapse_results(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 })
@@ -112,11 +113,11 @@ module Diametric
     #   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}" }
+      vars = model.attribute_names.map { |attribute| ~"?#{attribute}" }
 
       from = conditions.map { |k, _| ~"?#{k}" }
 
-      clauses = model.attributes.map { |attribute, _, _|
+      clauses = model.attribute_names.map { |attribute|
         [~"?e", model.namespace(model.prefix, attribute), ~"?#{attribute}"]
       }
       clauses += filters
@@ -153,5 +154,35 @@ module Diametric
         element
       end
     end
+
+    def collapse_results(res)
+      res.group_by(&:first).map do |dbid, results|
+        # extract dbid from results
+        # NOTE: we prefer to_a.drop(1) over block arg decomposition because
+        #       result may be a Java::ClojureLang::PersistentVector
+        results = results.map {|result| result.to_a.drop(1) }
+
+        # Group values from all results into one result set
+        # [["b", 123], ["c", 123]] #=> [["b", "c"], [123, 123]]
+        grouped_values = results.transpose
+
+        # Attach attribute names to each collection of values
+        # => [[:letters, ["b", "c"]], [:number, [123, 123]]]
+        attr_to_values = model.attributes.keys.zip(grouped_values)
+
+        # Retain cardinality/many attributes as a collection,
+        # but pick only one value for cardinality/one attributes
+        collapsed_values = attr_to_values.map do |attr, values|
+          if model.attributes[attr][:cardinality] == :many
+            values
+          else
+            values.first
+          end
+        end
+
+        # Returning a singular result for each dbid
+        [dbid, *collapsed_values]
+      end
+    end
   end
 end

data/lib/diametric/railtie.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require "diametric"
+require "diametric/config"
+
+require "rails"
+
+require 'diametric/generators/active_model'
+
+module Rails
+  module Diametric
+    class Railtie < Rails::Railtie
+
+      config.app_generators.orm :diametric
+
+      # Initialize Diametric. This will look for a diametric.yml in the config
+      # directory and configure diametric appropriately.
+      initializer "setup database" do
+        config_file = Rails.root.join("config", "diametric.yml")
+        if config_file.file?
+          begin
+            ::Diametric::Config.load_and_connect!(config_file)
+          rescue Exception => e
+            handle_configuration_error(e)
+          end
+        end
+      end
+
+      # After initialization we will warn the user if we can't find a diametric.yml and
+      # alert to create one.
+      initializer "warn when configuration is missing" do
+        config.after_initialize do
+          unless Rails.root.join("config", "diametric.yml").file? || ::Diametric::Config.configured?
+            puts "\nDiametric config not found. Create a config file at: config/diametric.yml"
+            puts "to generate one run: rails generate diametric:config\n\n"
+          end
+        end
+      end
+      rake_tasks do
+        require "#{File.join(File.dirname(__FILE__), "..", "tasks", "create_schema.rb")}"
+        require "#{File.join(File.dirname(__FILE__), "..", "tasks", "diametric_config.rb")}"
+      end
+      # Rails runs all initializers first before getting into any generator
+      # code, so we have no way in the initializer to know if we are
+      # generating a diametric.yml. So instead of failing, we catch all the
+      # errors and print them out.
+      def handle_configuration_error(e)
+        puts "There is a configuration error with the current diametric.yml."
+        puts e.message
+      end
+    end
+  end
+end

data/lib/diametric/version.rb

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

data/lib/tasks/create_schema.rb

@@ -0,0 +1,27 @@
+require 'rake'
+namespace :diametric do
+  desc "Create schema on datomic for REST connection"
+  task :create_schema => :environment do
+    create_schema
+  end
+
+  # intentionally, no desc for this task
+  # this task is used inside of the rails app
+  task :create_schema_for_peer do
+    create_schema(false)
+  end
+end
+
+def create_schema(print_info=true)
+  puts "Creating all schemas ..." if print_info
+  Dir.glob(File.join(Rails.root, "app", "models", "*.rb")).each {|model| load model}
+  Module.constants.each do |const|
+    class_def = eval "#{const.to_s}"
+    if class_def.respond_to? :create_schema
+      class_def.send(:create_schema)
+      puts class_def.send(:schema) if print_info
+    end
+  end
+  puts "done" if print_info
+end
+

data/lib/tasks/diametric_config.rb

@@ -0,0 +1,45 @@
+# This rake task creates config/diametric.yml file.
+# usage:
+#   rake diametric:config[REST,dbname,port,storage] ;=> for REST connection
+#   rake diametric:config[PEER,dbname]              ;=> for PEER connection
+#   rake diametric:config[FREE,dbname,port]         ;=> for Free transactor connection
+# examples:
+#   rake diametric:config[REST,sample,9000,test]    ;=> for REST, bin/rest 9000 test datomic:mem://
+#   rake diametric:config[PEER,sample]              ;=> for PEER
+#   rake diametric:config[FREE,sample,4334]         ;=> for Free transactor
+#
+# note:
+# For supporting pro version, perhaps, this should cover more configurations.
+# refs: http://docs.datomic.com/clojure/index.html#datomic.api/connect
+
+require 'rake'
+namespace :diametric do
+  desc "Generate config/diametric.yml"
+  task :config, [:type, :database, :port, :storage] => [:environment] do |t, args|
+    config = {"development" => {}}
+    case args[:type]
+      when "REST"
+        config["development"]["uri"]=rest_uri(args)
+        config["development"]["storage"]=args[:storage]
+        config["development"]["database"]=args[:database]
+      when "PEER"
+        config["development"]["uri"]=peer_uri(args)
+      when "FREE"
+        config["development"]["uri"]=free_uri(args)
+    end
+    puts config.to_yaml
+    File.open(File.join(Rails.root, "config", "diametric.yml"), "w").write(config.to_yaml)
+  end
+end
+
+def rest_uri(args)
+  ["http://localhost:", args[:port]].join
+end
+
+def peer_uri(args)
+  ["datomic:mem://", args[:database]].join
+end
+
+def free_uri(args)
+  ["datomic:free://localhost:", args[:port], "/", args[:database]].join
+end

data/spec/diametric/config_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Diametric::Config do
+  before do
+    Diametric::Config.configuration.clear
+  end
+
+  describe ".configuration" do
+    it "is empty by default" do
+      Diametric::Config.configuration.should have(0).options
+    end
+  end
+
+  describe ".configured?" do
+    it "is true if configuration is present" do
+      Diametric::Config.configuration[:uri] = 'datomic:free://sample'
+      Diametric::Config.should be_configured
+    end
+
+    it "is false if no configuration has been added" do
+      Diametric::Config.should_not be_configured
+    end
+  end
+
+  describe ".load_and_connect!" do
+    let(:path) { "/path/to/diametric.yml" }
+    let(:env) { :test }
+    let(:settings) { {'uri' => 'diametric:free://test'} }
+
+    it "loads settings from the environment" do
+      Diametric::Config::Environment.should_receive(:load_yaml).with(path, env).and_return(settings)
+      Diametric::Config.stub(:connect!)
+
+      Diametric::Config.load_and_connect!(path, env)
+    end
+
+    it "sets the configuration" do
+      Diametric::Config::Environment.stub(:load_yaml => settings)
+      Diametric::Config.stub(:connect!)
+      Diametric::Config.load_and_connect!(path, env)
+
+      Diametric::Config.configuration.should == settings
+    end
+
+    it "connects" do
+      Diametric::Config::Environment.stub(:load_yaml => settings)
+      Diametric::Config.should_receive(:connect!).with(settings)
+
+      Diametric::Config.load_and_connect!(path, env)
+    end
+  end
+
+  describe ".connect!" do
+    it "establishes a base connection" do
+      settings = stub
+      Diametric::Persistence.should_receive(:establish_base_connection).with(settings)
+      Diametric::Config.connect!(settings)
+    end
+  end
+end