universe_compiler 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 475dd9ec0d2b0bf95696301523c3e1dc4868c709
-  data.tar.gz: f28660a5b552fcf7b2175f4bb02a8cd31d2a88c7
+  metadata.gz: 7c633cfd0dd50f6ceea4998f90c90927767fadae
+  data.tar.gz: 15af4ae0a658e49c2943315c1713b553c280622e
 SHA512:
-  metadata.gz: f0f0fbc2d9341bff4abc9c729ce0194e6ee83aa79238950050cf47909243236002e2932c0df9a52591bac42270b5b852c82ec030af1900974ea9a2b3cb7773b7
-  data.tar.gz: 0a9ae7ce32452b26d617faf4e06d276165980d2db39097124a6443adae37302c5b692fc37aa4003527ecc281ce3fbe27ac642dfd3012de733e061685bac64415
+  metadata.gz: 6da30e7fe34302bad36cc3a1a79d28840ed25a7fbe7d8c11339ccc8c86b893feaba659c344a88c59e31a62cb46a9a7b25feb97d0929c7bcc60ad932a903371c8
+  data.tar.gz: d6422c866a2b525fc37d2f435c0c57ae4603f6481db994da66d85191e0335511e87329d283988aa798fc1cc570615b2567c690560d50e37f6c9387c3295f39a1

data/README.md

@@ -15,6 +15,8 @@ UniverseCompiler
         - [Relational directives](#relational-directives)
             - [Basic relations](#basic-relations)
             - [Advanced relations](#advanced-relations)
+                - [Reverse methods](#reverse-methods)
+                - [Strict vs permissive](#strict-vs-permissive)
         - [Validations](#validations)
     - [Compilation](#compilation)
     - [Inheritance](#inheritance)
@@ -274,6 +276,8 @@ e.bars == e[:bars]
 
 #### Advanced relations
 
+##### Reverse methods
+
 Sometimes you may want entities _targeted_ by `has_one` or `has_many` relations to _be aware_ of this fact. **You can then implement complex relations without duplicating information**.
 
 This is called **reverse methods**.
@@ -342,6 +346,52 @@ t.leaves.last.trunk
 An exception is returned. the `unique` option actually specifies that only one entity should reference it !
 If you don't specify this option, an array is returned instead and this check is not performed.
 
+##### Strict vs permissive
+
+By default, when a relation is declared between entities using `has_one` or `has_many`, the relation is said to be _permissive_, ie subclasses are allowed to be used for the relation. For example, let's consider the following classes:
+
+```ruby
+class Level1 < UniverseCompiler::Entity::Base
+  entity_type :level1
+
+  has_one :level1, name: :permissive_link
+
+end
+
+class Level2 < RootLevel
+  entity_type :level2
+end
+
+class Level3 < Level2
+  entity_type :level3
+end
+```
+
+It means that any instance of `Level2` or `Level3` can be used in the `has_one` relation declared in `Level1`. This is the default behavior.
+
+But if you consider the following classes:
+
+```ruby
+class Level1 < UniverseCompiler::Entity::Base
+  entity_type :level1
+
+  has_one :level1, name: :strict_link, strict_type: true
+
+end
+
+class Level2 < RootLevel
+  entity_type :level2
+end
+
+class Level3 < Level2
+  entity_type :level3
+end
+```
+
+Then only `Level1` instances will be valid for the `has_one` relation declared. The keyword as you guessed is `strict_type: true`.
+
+:information_source: It works the same way for `has_many` relations, applied to **all** instances added to the array...
+
 ### Validations
 
 Every constraint defined on a field or a relation is enforced when an entity is validated (which is as well true when saving it). Continuing on previous example:

data/lib/universe_compiler/entity/relations_management.rb

@@ -5,10 +5,11 @@ module UniverseCompiler
 
     module RelationsManagement
 
-      def has_one(target_entity_type_or_class, name: nil, with_reverse_method: nil, unique: false)
+      def has_one(target_entity_type_or_class, name: nil, strict_type: false, with_reverse_method: nil, unique: false)
         target_entity_type = normalize_entity_type target_entity_type_or_class
         field_name = relation_field_name name, target_entity_type
         define_constraint field_name, :has_one, target_entity_type
+        define_constraint field_name, :strict_type, target_entity_type if strict_type
         return unless with_reverse_method
 
         define_constraint_for_reverse_method :has_one,
@@ -18,11 +19,12 @@ module UniverseCompiler
                                              unique
       end
 
-      def has_many(target_entity_type_or_class, name: nil, with_reverse_method: nil, unique: false)
+      def has_many(target_entity_type_or_class, name: nil, strict_type: false, with_reverse_method: nil, unique: false)
         target_entity_type = normalize_entity_type target_entity_type_or_class
         field_name = relation_field_name name, target_entity_type
         field_name = field_name.to_s.pluralize.to_sym if name.nil?
         define_constraint field_name, :has_many, target_entity_type
+        define_constraint field_name, :strict_type, target_entity_type if strict_type
         return unless with_reverse_method
 
         define_constraint_for_reverse_method :has_many,

data/lib/universe_compiler/entity/validation.rb

@@ -35,9 +35,7 @@ module UniverseCompiler
               end
             when :has_one
               unless fields[field_name].nil?
-                if fields[field_name].respond_to? :type
-                  invalid_for_constraint invalid, field_name, constraint_name, value unless fields[field_name].type == value
-                else
+                unless provided_entity_compatible_with_type? fields[field_name], value, constraints[:strict_type]
                   invalid_for_constraint invalid, field_name, constraint_name, value
                 end
               end
@@ -46,9 +44,7 @@ module UniverseCompiler
                 invalid_for_constraint invalid, field_name, constraint_name, value
               else
                 fields[field_name].each do |related_object|
-                  if related_object.respond_to? :type
-                    invalid_for_constraint invalid, field_name, constraint_name, value unless related_object.type == value
-                  else
+                  unless provided_entity_compatible_with_type? related_object, value, constraints[:strict_type]
                     invalid_for_constraint invalid, field_name, constraint_name, value
                   end
                 end
@@ -87,6 +83,15 @@ module UniverseCompiler
 
       private
 
+      def provided_entity_compatible_with_type?(linked_object, declared_type, strict_type)
+        declared_class = UniverseCompiler::Entity::TypeManagement.type_class_mapping(declared_type)
+        if strict_type
+          linked_object.class == declared_class
+        else
+          linked_object.is_a? declared_class
+        end
+      end
+
       def invalid_for_constraint(invalid_fields_definition, field_name, constraint_name, value)
         invalid_fields_definition[field_name] ||= []
         invalid_fields_definition[field_name] << { constraint_name => value}

data/lib/universe_compiler/version.rb

@@ -1,3 +1,3 @@
 module UniverseCompiler
-  VERSION = '0.5.5'.freeze
+  VERSION = '0.5.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: universe_compiler
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.5.6
 platform: ruby
 authors:
 - Laurent B.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-05 00:00:00.000000000 Z
+date: 2019-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler