vorpal 1.0.1 → 1.2.1

data/lib/vorpal/dsl/config_builder.rb

@@ -16,59 +16,32 @@ module Vorpal
       @defaults_generator = DefaultsGenerator.new(clazz, db_driver)
     end
 
-    # Maps the given attributes to and from the domain object and the DB. Not needed
-    # if a serializer and deserializer were provided.
+    # @private
     def attributes(*attributes)
       @attributes.concat(attributes)
     end
 
-    # Defines a one-to-many association with a list of objects of the same type.
-    #
-    # @param name [String] Name of the attribute that will refer to the other object.
-    # @param options [Hash]
-    # @option options [Boolean] :owned
-    # @option options [String] :fk
-    # @option options [String] :fk_type
-    # @option options [Class] :child_class
+    # @private
     def has_many(name, options={})
-      @has_manys << {name: name}.merge(options)
+      @has_manys << build_has_many({name: name}.merge(options))
     end
 
-    # Defines a one-to-one association with another object where the foreign key
-    # is stored on the other object.
-    #
-    # @param name [String] Name of the attribute that will refer to the other object.
-    # @param options [Hash]
-    # @option options [Boolean] :owned
-    # @option options [String] :fk
-    # @option options [String] :fk_type
-    # @option options [Class] :child_class
+    # @private
     def has_one(name, options={})
-      @has_ones << {name: name}.merge(options)
+      @has_ones << build_has_one({name: name}.merge(options))
     end
 
-    # Defines a one-to-one association with another object where the foreign key
-    # is stored on this object.
-    #
-    # This association can be polymorphic. i.e.
-    #
-    # @param name [String] Name of the attribute that will refer to the other object.
-    # @param options [Hash]
-    # @option options [Boolean] :owned
-    # @option options [String] :fk
-    # @option options [String] :fk_type
-    # @option options [Class] :child_class
-    # @option options [[Class]] :child_classes
+    # @private
     def belongs_to(name, options={})
-      @belongs_tos << {name: name}.merge(options)
+      @belongs_tos << build_belongs_to({name: name}.merge(options))
     end
 
     # @private
     def build
       class_config = build_class_config
-      class_config.has_manys = build_has_manys
-      class_config.has_ones = build_has_ones
-      class_config.belongs_tos = build_belongs_tos
+      class_config.has_manys = @has_manys
+      class_config.has_ones = @has_ones
+      class_config.belongs_tos = @belongs_tos
 
       class_config
     end
@@ -81,18 +54,15 @@ module Vorpal
     private
 
     def build_class_config
-      Vorpal::ClassConfig.new(
+      Vorpal::Config::ClassConfig.new(
         domain_class: @domain_class,
         db_class: @class_options[:to] || @defaults_generator.build_db_class(@class_options[:table_name]),
         serializer: @class_options[:serializer] || @defaults_generator.serializer(attributes_with_id),
         deserializer: @class_options[:deserializer] || @defaults_generator.deserializer(attributes_with_id),
+        primary_key_type: @class_options[:primary_key_type] || @class_options[:id] || :serial,
       )
     end
 
-    def build_has_manys
-      @has_manys.map { |options| build_has_many(options) }
-    end
-
     def build_has_many(options)
       options[:child_class] ||= @defaults_generator.child_class(options[:name])
       options[:fk] ||= @defaults_generator.foreign_key(@domain_class.name)
@@ -100,10 +70,6 @@ module Vorpal
       Vorpal::HasManyConfig.new(options)
     end
 
-    def build_has_ones
-      @has_ones.map { |options| build_has_one(options) }
-    end
-
     def build_has_one(options)
       options[:child_class] ||= @defaults_generator.child_class(options[:name])
       options[:fk] ||= @defaults_generator.foreign_key(@domain_class.name)
@@ -111,10 +77,6 @@ module Vorpal
       Vorpal::HasOneConfig.new(options)
     end
 
-    def build_belongs_tos
-      @belongs_tos.map { |options| build_belongs_to(options) }
-    end
-
     def build_belongs_to(options)
       child_class = options[:child_classes] || options[:child_class] || @defaults_generator.child_class(options[:name])
       options[:child_classes] = Array(child_class)

data/lib/vorpal/dsl/configuration.rb

@@ -4,54 +4,143 @@ require 'vorpal/driver/postgresql'
 
 module Vorpal
   module Dsl
-  module Configuration
-
-    # Configures and creates a {Engine} instance.
-    #
-    # @param options [Hash] Global configuration options for the engine instance.
-    # @option options [Object] :db_driver (Object that will be used to interact with the DB.)
-    #  Must be duck-type compatible with {Postgresql}.
+    # Implements the Vorpal DSL.
     #
-    # @return [Engine] Instance of the mapping engine.
-    def define(options={}, &block)
-      master_config = build_config(&block)
-      db_driver = options.fetch(:db_driver, Driver::Postgresql.new)
-      Engine.new(db_driver, master_config)
-    end
-
-    # Maps a domain class to a relational table.
+    # ```ruby
+    # engine = Vorpal.define do
+    #   map Tree do
+    #     attributes :name
+    #     belongs_to :trunk
+    #     has_many :branches
+    #   end
     #
-    # @param domain_class [Class] Type of the domain model to be mapped
-    # @param options [Hash] Configure how to map the domain model
-    # @option options [String] :to
-    #   Class of the ActiveRecord object that will map this domain class to the DB.
-    #   Optional, if one is not specified, it will be generated.
-    # @option options [Object] :serializer (map the {ConfigBuilder#attributes} directly)
-    #   Object that will convert the domain objects into a hash.
+    #   map Trunk do
+    #     attributes :length
+    #     has_one :tree
+    #   end
     #
-    #   Must have a `(Hash) serialize(Object)` method.
-    # @option options [Object] :deserializer (map the {ConfigBuilder#attributes} directly)
-    #   Object that will set a hash of attribute_names->values onto a new domain
-    #   object.
+    #   map Branch do
+    #     attributes :length
+    #     belongs_to :tree
+    #   end
+    # end
     #
-    #   Must have a `(Object) deserialize(Object, Hash)` method.
-    def map(domain_class, options={}, &block)
-      @class_configs << build_class_config(domain_class, options, &block)
-    end
+    # mapper = engine.mapper_for(Tree)
+    # ```
+    module Configuration
+      # Configures and creates a {Engine} instance.
+      #
+      # @param options [Hash] Global configuration options for the engine instance.
+      # @option options [Object] :db_driver (Object that will be used to interact with the DB.)
+      #  Must be duck-type compatible with {Postgresql}.
+      #
+      # @return [Engine] Instance of the mapping engine.
+      def define(options={}, &block)
+        @main_config = MainConfig.new
+        instance_exec(&block)
+        @main_config.initialize_association_configs
+        db_driver = options.fetch(:db_driver, Driver::Postgresql.new)
+        engine = Engine.new(db_driver, @main_config)
+        @main_config = nil # make sure this MainConfig is never re-used by accident.
+        engine
+      end
 
-    # @private
-    def build_class_config(domain_class, options={}, &block)
-      builder = ConfigBuilder.new(domain_class, options, Driver::Postgresql.new)
-      builder.instance_exec(&block) if block_given?
-      builder.build
-    end
+      # Maps a domain class to a relational table.
+      #
+      # @param domain_class [Class] Type of the domain model to be mapped
+      # @param options [Hash] Configure how to map the domain model
+      # @option options [String] :to
+      #   Class of the ActiveRecord object that will map this domain class to the DB.
+      #   Optional, if one is not specified, it will be generated.
+      # @option options [Object] :serializer (map the {ConfigBuilder#attributes} directly)
+      #   Object that will convert the domain objects into a hash.
+      #
+      #   Must have a `(Hash) serialize(Object)` method.
+      # @option options [Object] :deserializer (map the {ConfigBuilder#attributes} directly)
+      #   Object that will set a hash of attribute_names->values onto a new domain
+      #   object.
+      #
+      #   Must have a `(Object) deserialize(Object, Hash)` method.
+      #  @option options [Symbol] :primary_key_type [:serial, :uuid] (:serial)
+      #    The type of primary key for the class. :serial for auto-incrementing integer, :uuid for a UUID
+      #  @option options [Symbol] :id
+      #    Same as :primary_key_type. Exists for compatibility with the Rails API.
+      def map(domain_class, options={}, &block)
+        class_config = build_class_config(domain_class, options, &block)
+        @main_config.add_class_config(class_config)
+        class_config
+      end
 
-    # @private
-    def build_config(&block)
-      @class_configs = []
-      self.instance_exec(&block)
-      MasterConfig.new(@class_configs)
+      # @private
+      def build_class_config(domain_class, options, &block)
+        @builder = ConfigBuilder.new(domain_class, options, Driver::Postgresql.new)
+        instance_exec(&block) if block_given?
+        class_config = @builder.build
+        @builder = nil # make sure this ConfigBuilder is never re-used by accident.
+        class_config
+      end
+
+      # Maps the given attributes to and from the domain object and the DB. Not needed
+      # if a serializer and deserializer were provided.
+      def attributes(*attributes)
+        @builder.attributes(*attributes)
+      end
+
+      # Defines a one-to-many association to another type where the foreign key is stored on the child.
+      #
+      # In Object-Oriented programming, associations are *directed*. This means that they can only be
+      # traversed in one direction: from the type that defines the association (the one with the
+      # getter) to the type that is associated. They end that defines the association is called the
+      # 'Parent' and the end that is associated is called the 'Child'.
+      #
+      # @param name [String] Name of the association getter.
+      # @param options [Hash]
+      # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
+      # @option options [String] :fk (Parent class name converted to snakecase and appended with a '_id') The name of the DB column on the child that contains the foreign key reference to the parent.
+      # @option options [String] :fk_type The name of the DB column on the child that contains the parent class name. Only needed when there is an association from the child side that is polymorphic.
+      # @option options [Class] :child_class (name converted to a Class) The child class.
+      def has_many(name, options={})
+        @builder.has_many(name, options)
+      end
+
+      # Defines a one-to-one association to another type where the foreign key
+      # is stored on the child.
+      #
+      # In Object-Oriented programming, associations are *directed*. This means that they can only be
+      # traversed in one direction: from the type that defines the association (the one with the
+      # getter) to the type that is associated. They end that defines the association is called the
+      # 'Parent' and the end that is associated is called the 'Child'.
+      #
+      # @param name [String] Name of the association getter.
+      # @param options [Hash]
+      # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
+      # @option options [String] :fk (Parent class name converted to snakecase and appended with a '_id') The name of the DB column on the child that contains the foreign key reference to the parent.
+      # @option options [String] :fk_type The name of the DB column on the child that contains the parent class name. Only needed when there is an association from the child side that is polymorphic.
+      # @option options [Class] :child_class (name converted to a Class) The child class.
+      def has_one(name, options={})
+        @builder.has_one(name, options)
+      end
+
+      # Defines a one-to-one association with another type where the foreign key
+      # is stored on the parent.
+      #
+      # This association can be polymorphic. I.E. children can be of different types.
+      #
+      # In Object-Oriented programming, associations are *directed*. This means that they can only be
+      # traversed in one direction: from the type that defines the association (the one with the
+      # getter) to the type that is associated. They end that defines the association is called the
+      # 'Parent' and the end that is associated is called the 'Child'.
+      #
+      # @param name [String] Name of the association getter.
+      # @param options [Hash]
+      # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
+      # @option options [String] :fk (Child class name converted to snakecase and appended with a '_id') The name of the DB column on the parent that contains the foreign key reference to the child.
+      # @option options [String] :fk_type The name of the DB column on the parent that contains the child class name. Only needed when the association is polymorphic.
+      # @option options [Class] :child_class (name converted to a Class) The child class.
+      # @option options [[Class]] :child_classes The list of possible classes that can be children. This is for polymorphic associations. Takes precedence over `:child_class`.
+      def belongs_to(name, options={})
+        @builder.belongs_to(name, options)
+      end
     end
   end
-  end
 end

data/lib/vorpal/dsl/defaults_generator.rb

@@ -1,6 +1,6 @@
 require 'simple_serializer/serializer'
 require 'simple_serializer/deserializer'
-require 'active_support/inflector/methods'
+require 'active_support'
 require 'active_support/core_ext/module/introspection'
 
 module Vorpal
@@ -36,9 +36,19 @@ module Vorpal
     end
 
     def child_class(association_name)
-      # Module#parent comes from 'active_support/core_ext/module/introspection'
-      parent_module = @domain_class.parent
-      parent_module.const_get(ActiveSupport::Inflector.classify(association_name.to_s))
+      module_parent.const_get(ActiveSupport::Inflector.classify(association_name.to_s))
+    end
+
+    private
+
+    def module_parent
+      if (ActiveSupport::VERSION::MAJOR == 5)
+        # Module#parent comes from 'active_support/core_ext/module/introspection'
+        @domain_class.parent
+      else
+        # Module#module_parent comes from 'active_support/core_ext/module/introspection'
+        @domain_class.module_parent
+      end
     end
   end
   end

data/lib/vorpal/engine.rb

@@ -7,9 +7,9 @@ require 'vorpal/exceptions'
 module Vorpal
   class Engine
     # @private
-    def initialize(db_driver, master_config)
+    def initialize(db_driver, main_config)
       @db_driver = db_driver
-      @configs = master_config
+      @configs = main_config
     end
 
     # Creates a mapper for saving/updating/loading/destroying an aggregate to/from
@@ -34,6 +34,9 @@ module Vorpal
       serialize(all_owned_objects, mapping, loaded_db_objects)
       new_objects = get_unsaved_objects(mapping.keys)
       begin
+        # Primary keys are set eagerly (instead of waiting for them to be set by ActiveRecord upon create)
+        # because we want to support non-null FK constraints without needing to figure the correct
+        # order to save entities in.
         set_primary_keys(all_owned_objects, mapping)
         set_foreign_keys(all_owned_objects, mapping)
         remove_orphans(mapping, loaded_db_objects)
@@ -89,10 +92,16 @@ module Vorpal
       @configs.config_for(domain_class).db_class
     end
 
+    # Try to use {AggregateMapper#query} instead.
     def query(domain_class)
       @db_driver.query(@configs.config_for(domain_class).db_class, mapper_for(domain_class))
     end
 
+    # @private
+    def class_config(domain_class)
+      @configs.config_for(domain_class)
+    end
+
     private
 
     def wrap(collection_or_not)
@@ -150,10 +159,10 @@ module Vorpal
     def serialize_object(object, config, loaded_db_objects)
       if config.serialization_required?
         attributes = config.serialize(object)
-        if object.id.nil?
+        db_object = loaded_db_objects.find_by_id(config, object.id)
+        if object.id.nil? || db_object.nil? # object doesn't exist in the DB
           config.build_db_object(attributes)
         else
-          db_object = loaded_db_objects.find_by_id(config, object.id)
           config.set_db_object_attributes(db_object, attributes)
           db_object
         end
@@ -165,7 +174,11 @@ module Vorpal
     def set_primary_keys(owned_objects, mapping)
       owned_objects.each do |config, objects|
         in_need_of_primary_keys = objects.find_all { |obj| obj.id.nil? }
-        primary_keys = @db_driver.get_primary_keys(config.db_class, in_need_of_primary_keys.length)
+        if config.primary_key_type == :uuid
+          primary_keys = Array.new(in_need_of_primary_keys.length) { SecureRandom.uuid }
+        elsif config.primary_key_type == :serial
+          primary_keys = @db_driver.get_primary_keys(config.db_class, in_need_of_primary_keys.length)
+        end
         in_need_of_primary_keys.zip(primary_keys).each do |object, primary_key|
           mapping[object].id = primary_key
           object.id = primary_key

data/lib/vorpal/identity_map.rb

@@ -1,22 +1,23 @@
 module Vorpal
+  # Maps DB rows to Entities
   class IdentityMap
     def initialize
       @entities = {}
     end
 
-    def get(key_object)
-      @entities[key(key_object)]
+    def get(db_row)
+      @entities[key(db_row)]
     end
 
-    def set(key_object, object)
-      @entities[key(key_object)] = object
+    def set(db_row, entity)
+      @entities[key(db_row)] = entity
     end
 
-    def get_and_set(key_object)
-      object = get(key_object)
-      object = yield if object.nil?
-      set(key_object, object)
-      object
+    def get_and_set(db_row)
+      entity = get(db_row)
+      entity = yield if entity.nil?
+      set(db_row, entity)
+      entity
     end
 
     def map(key_objects)
@@ -25,11 +26,11 @@ module Vorpal
 
     private
 
-    def key(key_object)
-      return nil unless key_object
-      raise "Cannot put entity '#{key_object.inspect}' into IdentityMap without an id." if key_object.id.nil?
-      raise "Cannot put entity '#{key_object.inspect}' into IdentityMap without a Class with a name." if key_object.class.name.nil?
-      [key_object.id, key_object.class.name]
+    def key(db_row)
+      return nil unless db_row
+      raise "Cannot map a DB row without an id '#{db_row.inspect}' to an entity." if db_row.id.nil?
+      raise "Cannot map a DB row without a Class with a name '#{db_row.inspect}' to an entity." if db_row.class.name.nil?
+      [db_row.id, db_row.class.name]
     end
   end
 end

data/lib/vorpal/version.rb

@@ -1,3 +1,3 @@
 module Vorpal
-  VERSION = "1.0.1"
+  VERSION = "1.2.1"
 end

data/vorpal.gemspec

@@ -13,22 +13,22 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/nulogy/vorpal"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files         = Dir["CHANGELOG.md", "LICENSE.txt", "README.md", "vorpal.gemspec", "lib/**/*"]
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "simple_serializer", "~> 1.0"
   spec.add_runtime_dependency "equalizer"
   spec.add_runtime_dependency "activesupport"
 
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "virtus", "~> 1.0"
   spec.add_development_dependency "appraisal", "~> 2.2"
 
-  spec.required_ruby_version = ">= 2.1.6"
-  spec.add_development_dependency "activerecord", "~> 4.1.0"
-  spec.add_development_dependency "pg", "~> 0.17.0"
-  spec.add_development_dependency "activerecord-import", "~> 0.10.0"
+  spec.required_ruby_version = ">= 2.5.7"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "pg"
+  spec.add_development_dependency "activerecord-import"
+  spec.add_development_dependency "codecov"
 end