lib/reality/facets/facet_container.rb in reality-facets-1.5.0 vs lib/reality/facets/facet_container.rb in reality-facets-1.6.0

@@ -17,21 +17,33 @@
     module FacetContainer
       def self.extended(base)
         base.class_eval 'module FacetDefinitions; end'
       end
 
-      def facet?(key)
-        facet_by_name?(key)
+      # An array of modules that should be mixed in to every extension object
+      def facet_extensions
+        facet_extension_list.dup
       end
 
-      def facet_by_name?(key)
-        !!facet_map[key.to_s]
+      # Add a ruby module that will be applied to all extension objects
+      def facet_extension(extension)
+        Facets.error("Attempting to define facet extension #{extension} after facet manager is locked") if locked?
+        facet_extension_list << extension
+        target_manager.lock!
       end
 
-      def facet_by_name(key)
-        facet = facet_map[key.to_s]
-        Facets.error("Unknown facet '#{key}'") unless facet
+      def facet?(name)
+        facet_by_name?(name)
+      end
+
+      def facet_by_name?(name)
+        !!facet_map[name.to_s]
+      end
+
+      def facet_by_name(name)
+        facet = facet_map[name.to_s]
+        Facets.error("Unknown facet '#{name}'") unless facet
         facet
       end
 
       def facet(definition, options = {}, &block)
         Facets.error("Unknown definition form '#{definition.inspect}'") unless (definition.is_a?(Symbol) || (definition.is_a?(Hash) && 1 == definition.size))
@@ -46,10 +58,19 @@
 
       def facets
         facet_map.values
       end
 
+      def lock!
+        @locked = true
+        apply_facet_extensions
+      end
+
+      def locked?
+        !!(@locked ||= nil)
+      end
+
       def target_manager
         @target_manager ||= Reality::Facets::TargetManager.new(self)
       end
 
       def facet_definitions
@@ -71,55 +92,55 @@
           end
         end
         results
       end
 
-      def activate_facet(object, facet_key)
-        return if object.facet_enabled?(facet_key)
+      def activate_facet(object, facet_name)
+        return if object.facet_enabled?(facet_name)
 
-        facet = facet_by_name(facet_key)
+        facet = facet_by_name(facet_name)
         facet.required_facets.each do |required_facet_key|
           activate_facet(object, required_facet_key)
         end
         facet.suggested_facets.each do |suggested_facet_key|
           activate_facet(object, suggested_facet_key)
         end
-        object.send(:"_enable_facet_#{facet_key}!")
+        object.send(:"_enable_facet_#{facet_name}!")
 
         each_contained_model_object(object) do |child|
-          activate_facet(child, facet_key)
+          activate_facet(child, facet_name)
         end
       end
 
-      def deactivate_facet(object, facet_key)
-        return unless object.facet_enabled?(facet_key)
+      def deactivate_facet(object, facet_name)
+        return unless object.facet_enabled?(facet_name)
         each_contained_model_object(object) do |child|
-          deactivate_facet(child, facet_key)
+          deactivate_facet(child, facet_name)
         end
 
         facets.each do |facet|
-          if facet.required_facets.include?(facet_key)
+          if facet.required_facets.include?(facet_name)
             deactivate_facet(object, facet.key)
           end
         end
-        object.send(:"_disable_facet_#{facet_key}!")
+        object.send(:"_disable_facet_#{facet_name}!")
       end
 
       def extension_point(object, action)
         # noinspection RubyNestedTernaryOperatorsInspection
         name = object.respond_to?(:qualified_name) ? object.qualified_name : object.respond_to?(:name) ? object.name : object.to_s
         if object.respond_to?(action, true)
           Facets.debug "Running '#{action}' hook on #{object.class} #{name}"
           object.send(action)
         end
-        object.enabled_facets.each do |facet_key|
+        object.enabled_facets.each do |facet_name|
           # Need to check for the magic facet_X method rather than X method directly as
           # sometimes there is a global method of the same name.
-          method_name = "facet_#{facet_key}"
+          method_name = "facet_#{facet_name}"
           extension_object = object.respond_to?(method_name) ? object.send(method_name) : nil
           if extension_object && extension_object.respond_to?(action, true)
-            Facets.debug "Running '#{action}' hook on #{facet_key} facet of #{object.class} #{name}"
+            Facets.debug "Running '#{action}' hook on #{facet_name} facet of #{object.class} #{name}"
             extension_object.send(action)
           end
         end
         each_contained_model_object(object) do |child|
           extension_point(child, action)
@@ -143,11 +164,30 @@
 
       def handle_sub_feature?(object, sub_feature_key)
         true
       end
 
+      def apply_facet_extensions
+        facet_extension_list.each do |extension|
+          facet_map.values.each do |facet|
+            target_manager.targets.each do |target|
+              if facet.enhanced?(target.model_class)
+                facet.enhance(target.model_class) do
+                  include extension
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def facet_extension_list
+        @facet_extensions ||= []
+      end
+
       def register_facet(facet)
-        target_manager.lock_targets
+        target_manager.lock!
+        Facets.error("Attempting to define facet #{facet.key} after facet manager is locked") if locked?
         Facets.error("Attempting to redefine facet #{facet.key}") if facet_map[facet.key.to_s]
         facet_map[facet.key.to_s] = facet
       end
 
       # Map a facet key to a map. The map maps types to extension classes