reality-facets 1.0.0

data/lib/reality/facets/faceted_model.rb

@@ -0,0 +1,98 @@
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Reality #nodoc
+  module Facets #nodoc
+
+    # Module that should be mixed into all model objects that have facets.
+    # Implementation should define a method `facet_container` that retrieves
+    # the associated manager.
+    module Faceted
+
+      def facet_enabled?(facet_key)
+        method_name = :"#{facet_key}?"
+        self.respond_to?(method_name) ? self.send(method_name) : false
+      end
+
+      def facet(facet_key)
+        self.send(facet_key)
+      end
+
+      def enabled_facets
+        (@enabled_facets ||= []).dup
+      end
+
+      def enable_facet(key)
+        Facets.error("Facet #{key} already enabled.") if self.facet_enabled?(key)
+        self.activate_facet(key)
+      end
+
+      def enable_facets!(*keys)
+        keys = keys[0] if keys.size == 1 && keys[0].is_a?(Array)
+        keys.flatten.each do |key|
+          enable_facet(key)
+        end
+      end
+
+      def enable_facets(*keys)
+        keys = keys[0] if keys.size == 1 && keys[0].is_a?(Array)
+        keys.flatten.each do |key|
+          self.activate_facet(key) unless self.facet_enabled?(key)
+        end
+      end
+
+      def disable_facet(key)
+        Facets.error("Facet #{key} not enabled.") unless self.facet_enabled?(key)
+        self.deactivate_facet(key)
+      end
+
+      def disable_facets!(*keys)
+        keys = keys[0] if keys.size == 1 && keys[0].is_a?(Array)
+        keys.flatten.each do |key|
+          disable_facet(key)
+        end
+      end
+
+      def disable_facets(*keys)
+        keys = keys[0] if keys.size == 1 && keys[0].is_a?(Array)
+        keys.flatten.each do |key|
+          disable_facet(key) if self.facet_enabled?(key)
+        end
+      end
+
+      def disable_facets_not_in(keys)
+        keys = keys[0] if keys.size == 1 && keys[0].is_a?(Array)
+        (self.enabled_facets - keys).each do |facet_key|
+          self.disable_facet(facet_key) if self.facet_enabled?(facet_key)
+        end
+      end
+
+      protected
+
+      def extension_point(action)
+        Facets.debug "Facet '#{self}' extension point #{action} started"
+        facet_container.extension_point(self, action)
+        Facets.debug "Facet '#{self}' extension point #{action} completed"
+      end
+
+      def activate_facet(facet_key)
+        facet_container.activate_facet(self, facet_key)
+      end
+
+      def deactivate_facet(facet_key)
+        facet_container.deactivate_facet(self, facet_key)
+      end
+    end
+  end
+end

data/lib/reality/facets/target_manager.rb

@@ -0,0 +1,143 @@
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Reality #nodoc
+  module Facets #nodoc
+
+    # A descriptor describing a base type in the system model.
+    class Target
+      def initialize(target_manager, model_class, key, container_key, options)
+        @target_manager = target_manager
+        @model_class = model_class
+        @key = key.to_sym
+        @access_method = (options[:access_method] || Reality::Naming.pluralize(@key)).to_sym
+        @inverse_access_method = (options[:inverse_access_method] || @key).to_sym
+        @container_key = container_key.nil? ? nil : container_key.to_sym
+        @extension_module = nil
+
+        if @container_key && !target_manager.target_by_key?(@container_key)
+          raise "Target '#{key}' defines container as '#{@container_key}' but no such target exists."
+        end
+
+        @target_manager.send(:register_target, self)
+      end
+
+      attr_reader :target_manager
+      attr_reader :model_class
+      attr_reader :key
+      attr_reader :container_key
+      attr_reader :access_method
+      attr_reader :inverse_access_method
+
+      def extension_module
+        unless @extension_module
+          outer_module = target_manager.container.facet_definitions
+          module_name = "#{::Reality::Naming.pascal_case(key)}Extension"
+          outer_module.class_eval "module #{module_name}\n end"
+          @extension_module = outer_module.const_get(module_name)
+          @extension_module.send(:include, Faceted)
+          @extension_module.class_eval("def parent; #{self.container_key}; end") if self.container_key
+          @extension_module.class_eval 'def facet_container; @facet_container; end'
+        end
+        @extension_module
+      end
+
+      def apply_extension_to(object)
+        raise "Can not apply extension to model object of type #{object.class} as it is not of expected model type #{model_class.name} for target #{key}" unless object.is_a?(model_class)
+        raise "Attempted to apply extension multiple time to model object of type #{model_class.name} for target #{key}" if object.instance_variable_defined?('@facet_extension_active')
+        object.class.send(:include, extension_module)
+        object.instance_variable_set('@facet_container', target_manager.container)
+        object.instance_variable_set('@facet_extension_active', true)
+
+        if self.container_key
+          container = object.send(self.container_key)
+          container.enabled_facets.each do |facet_key|
+            object.send(:"_enable_facet_#{facet_key}!")
+          end
+        end
+        object
+      end
+    end
+
+    class TargetManager
+      attr_reader :container
+
+      def initialize(container)
+        @container = container
+      end
+
+      def is_target_valid?(key)
+        target_map.keys.include?(key)
+      end
+
+      def target_keys
+        target_map.keys
+      end
+
+      def targets
+        target_map.values
+      end
+
+      def target_by_key?(key)
+        !!target_map[key]
+      end
+
+      def target_by_key(key)
+        target = target_map[key.to_sym]
+        raise "Can not find target with key '#{key}'" unless target
+        target
+      end
+
+      def target_by_model_class(model_class)
+        target_map.each do |key, target|
+          return target if target.model_class == model_class
+        end
+        raise "Can not find target with model class '#{model_class.name}'"
+      end
+
+      def apply_extension(model)
+        self.target_by_model_class(model.class).apply_extension_to(model)
+      end
+
+      def target(model_class, key, container_key = nil, options = {})
+        Target.new(self, model_class, key, container_key, options)
+      end
+
+      def targets_by_container(container_key)
+        target_map.values.select { |target| target.container_key == container_key }
+      end
+
+      def lock_targets
+        @targets_locked = true
+      end
+
+      def reset_targets
+        target_map.clear
+        @targets_locked = false
+      end
+
+      private
+
+      def register_target(target)
+        raise "Attempting to define target #{target.key} when targets have been locked." if (@targets_locked ||= false)
+        raise "Attempting to redefine target #{target.key}" if target_map[target.key]
+        target_map[target.key] = target
+      end
+
+      def target_map
+        @target_map ||= Reality::OrderedHash.new
+      end
+    end
+  end
+end

data/reality-facets.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name               = %q{reality-facets}
+  s.version            = '1.0.0'
+  s.platform           = Gem::Platform::RUBY
+
+  s.authors            = ['Peter Donald']
+  s.email              = %q{peter@realityforge.org}
+
+  s.homepage           = %q{https://github.com/realityforge/reality-facets}
+  s.summary            = %q{A basic toolkit for binding facets or extensions to model objects.}
+  s.description        = %q{A basic toolkit for binding facets or extensions to model objects.}
+
+  s.files              = `git ls-files`.split("\n")
+  s.test_files         = `git ls-files -- {spec}/*`.split("\n")
+  s.executables        = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.default_executable = []
+  s.require_paths      = %w(lib)
+
+  s.has_rdoc           = false
+  s.rdoc_options       = %w(--line-numbers --inline-source --title reality-facets)
+
+  s.add_dependency 'reality-core', '= 1.4.0'
+  s.add_dependency 'reality-naming', '= 1.4.0'
+  s.add_dependency 'reality-orderedhash', '= 1.0.0'
+
+  s.add_development_dependency(%q<minitest>, ['= 5.9.1'])
+  s.add_development_dependency(%q<test-unit>, ['= 3.1.5'])
+end

data/test/facets/test_facet.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../../helper', __FILE__)
+
+class Reality::Facets::TestFacet < Reality::TestCase
+  class Component < Reality.base_element(:name => true, :container_key => :project, :pre_config_code => 'Reality::TestCase::TestFacetContainer.target_manager.apply_extension(self)')
+  end
+
+  class Project < Reality.base_element(:name => true, :pre_config_code => 'Reality::TestCase::TestFacetContainer.target_manager.apply_extension(self)')
+    def component(name, options = {}, &block)
+      component_map[name.to_s] = Component.new(self, name, options, &block)
+    end
+
+    def comps
+      component_map.values
+    end
+
+    def component_map
+      @component_map ||= {}
+    end
+  end
+
+  def test_basic_operation
+
+    assert_equal false, TestFacetContainer.facet_by_name?(:gwt)
+    assert_equal false, TestFacetContainer.facet_by_name?(:gwt_rpc)
+    assert_equal false, TestFacetContainer.facet_by_name?(:imit)
+
+    TestFacetContainer.target_manager.target(Project, :project)
+    TestFacetContainer.target_manager.target(Component,
+                                             :component,
+                                             :project,
+                                             :access_method => :comps,
+                                             :inverse_access_method => :comp)
+
+    Reality::Facets::Facet.new(TestFacetContainer, :gwt)
+    Reality::Facets::Facet.new(TestFacetContainer, :gwt_rpc, :required_facets => [:gwt])
+
+    Reality::Facets::Facet.new(TestFacetContainer, :imit, :suggested_facets => [:gwt_rpc]) do |f|
+      f.enhance(Project) do
+        def name
+          "Gwt#{project.name}"
+        end
+      end
+      f.enhance(Component)
+    end
+
+    assert_equal true, TestFacetContainer.facet_by_name?(:gwt)
+    assert_equal true, TestFacetContainer.facet_by_name?(:gwt_rpc)
+    assert_equal true, TestFacetContainer.facet_by_name?(:imit)
+
+    project = Project.new(:MyProject) do |p|
+      p.enable_facets(:imit)
+      p.component(:MyComponent)
+    end
+    component = project.comps[0]
+
+    assert_equal true, project.gwt?
+    assert_equal false, project.respond_to?(:gwt)
+    assert_equal false, project.respond_to?(:facet_gwt)
+    assert_equal true, project.gwt_rpc?
+    assert_equal false, project.respond_to?(:gwt_rpc)
+    assert_equal false, project.respond_to?(:facet_gwt_rpc)
+    assert_equal true, project.imit?
+    assert_equal true, project.respond_to?(:imit)
+    assert_equal true, project.respond_to?(:facet_imit)
+    assert_equal 'GwtMyProject', project.imit.name
+
+    # These methods all test that FacetModule has been mixed in.
+    assert_equal 'GwtMyProject', project.facet(:imit).name
+    assert_equal true, project.facet_enabled?(:imit)
+
+    assert_equal [:gwt, :gwt_rpc, :imit], project.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :imit], component.enabled_facets
+
+    # Ensure there is a link back to the container using inverse_access_method
+    assert_equal project, project.imit.project
+    assert_equal project, project.imit.parent
+    assert_equal component, component.imit.comp
+    assert_equal component, component.imit.parent
+  end
+end

data/test/facets/test_facet_container.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../helper', __FILE__)
+
+class Reality::Facets::TestFacetContainer < Reality::TestCase
+  class Component < Reality.base_element(:name => true)
+  end
+
+  class Component2 < Reality.base_element(:name => true)
+  end
+
+  def test_basic_operation
+
+    assert_equal false, TestFacetContainer.facet_by_name?(:gwt)
+    assert_equal false, TestFacetContainer.facet?(:gwt)
+    assert_equal false, TestFacetContainer.facet_by_name?(:gwt_rpc)
+    assert_equal false, TestFacetContainer.facet?(:gwt_rpc)
+    assert_equal [], TestFacetContainer.facet_keys
+    assert_equal 0, TestFacetContainer.facets.size
+
+    assert_raise_message("Unknown facet 'gwt'") { TestFacetContainer.facet_by_name(:gwt) }
+    assert_raise_message("Unknown facet 'gwt_rpc'") { TestFacetContainer.facet_by_name(:gwt_rpc) }
+
+    # Make sure we can add targets
+    TestFacetContainer.target_manager.target(Component, :component)
+
+    TestFacetContainer.facet(:gwt)
+
+    # targets should be locked after first facet defined
+    assert_raise_message('Attempting to define target component when targets have been locked.') do
+      TestFacetContainer.target_manager.target(Component, :component)
+    end
+
+    assert_equal true, TestFacetContainer.facet_by_name?(:gwt)
+    assert_equal true, TestFacetContainer.facet?(:gwt)
+    assert_equal false, TestFacetContainer.facet_by_name?(:gwt_rpc)
+    assert_equal false, TestFacetContainer.facet?(:gwt_rpc)
+    assert_equal %w(gwt), TestFacetContainer.facet_keys
+    assert_equal 1, TestFacetContainer.facets.size
+
+    assert_raise_message("Unknown facet 'gwt_rpc'") { TestFacetContainer.facet_by_name(:gwt_rpc) }
+
+    assert_equal TestFacetContainer, TestFacetContainer.facet_by_name(:gwt).facet_container
+    assert_equal :gwt, TestFacetContainer.facet_by_name(:gwt).key
+    assert_equal [], TestFacetContainer.facet_by_name(:gwt).required_facets
+    assert_equal [], TestFacetContainer.facet_by_name(:gwt).suggested_facets
+
+    TestFacetContainer.facet(:gwt_rpc => [:gwt])
+
+    assert_equal true, TestFacetContainer.facet_by_name?(:gwt)
+    assert_equal true, TestFacetContainer.facet?(:gwt)
+    assert_equal true, TestFacetContainer.facet_by_name?(:gwt_rpc)
+    assert_equal true, TestFacetContainer.facet?(:gwt_rpc)
+    assert_equal %w(gwt gwt_rpc), TestFacetContainer.facet_keys
+    assert_equal 2, TestFacetContainer.facets.size
+
+    assert_equal TestFacetContainer, TestFacetContainer.facet_by_name(:gwt_rpc).facet_container
+    assert_equal :gwt_rpc, TestFacetContainer.facet_by_name(:gwt_rpc).key
+    assert_equal [:gwt], TestFacetContainer.facet_by_name(:gwt_rpc).required_facets
+    assert_equal [], TestFacetContainer.facet_by_name(:gwt_rpc).suggested_facets
+
+    assert_raise_message('Attempting to redefine facet gwt') { TestFacetContainer.facet(:gwt) }
+
+    assert_raise_message("Unknown definition form '{:x=>:y, :z=>1}'") { TestFacetContainer.facet(:x => :y, :z => 1) }
+  end
+end

data/test/facets/test_faceted_model.rb

@@ -0,0 +1,267 @@
+require File.expand_path('../../helper', __FILE__)
+
+class Reality::Facets::TestFacetedModel < Reality::TestCase
+  class Attribute < Reality.base_element(:name => true, :container_key => :entity)
+    def qualified_name
+      "#{entity.qualified_name}.#{name}"
+    end
+  end
+
+  class Entity < Reality.base_element(:name => true, :container_key => :repository)
+    def qualified_name
+      "#{repository.name}.#{name}"
+    end
+
+    def attribute(name, options = {}, &block)
+      attribute_map[name.to_s] = Attribute.new(self, name, options, &block)
+    end
+
+    def attributes
+      attribute_map.values
+    end
+
+    def attribute_map
+      @attribute_map ||= {}
+    end
+  end
+
+  class Repository < Reality.base_element(:name => true)
+    def entity(name, options = {}, &block)
+      entity_map[name.to_s] = Entity.new(self, name, options, &block)
+    end
+
+    def entities
+      entity_map.values
+    end
+
+    def entity_map
+      @entity_map ||= {}
+    end
+  end
+
+  def test_activation
+    TestFacetContainer.target_manager.target(Repository, :repository)
+    TestFacetContainer.target_manager.target(Entity, :entity, :repository)
+    TestFacetContainer.target_manager.target(Attribute, :attribute, :entity)
+
+    TestFacetContainer.facet(:json)
+    TestFacetContainer.facet(:jpa)
+    TestFacetContainer.facet(:gwt)
+    TestFacetContainer.facet(:gwt_rpc => [:gwt])
+    TestFacetContainer.facet(:imit => [:gwt_rpc]) do |f|
+      f.suggested_facets << :jpa
+    end
+
+    assert_equal 5, TestFacetContainer.facets.size
+
+    repository = Repository.new(:MyRepo) do |r|
+      TestFacetContainer.target_manager.apply_extension(r)
+
+      r.enable_facet(:json)
+
+      r.entity(:MyEntityA) do |e|
+        TestFacetContainer.target_manager.apply_extension(e)
+        e.attribute(:MyAttr1) do |a|
+          TestFacetContainer.target_manager.apply_extension(a)
+        end
+        e.disable_facet(:json)
+        e.attribute(:MyAttr2) do |a|
+          TestFacetContainer.target_manager.apply_extension(a)
+        end
+      end
+
+      r.entity(:MyEntityB) do |e|
+        TestFacetContainer.target_manager.apply_extension(e)
+      end
+    end
+
+    entity1 = repository.entities[0]
+    attribute1 = entity1.attributes[0]
+    attribute2 = entity1.attributes[1]
+    entity2 = repository.entities[1]
+
+    assert_equal [:json], repository.enabled_facets
+    assert_equal [], entity1.enabled_facets
+    assert_equal [:json], entity2.enabled_facets
+    assert_equal [], attribute1.enabled_facets
+    assert_equal [], attribute2.enabled_facets
+
+    repository.enable_facet(:imit)
+    assert_raise_message('Facet imit already enabled.') { repository.enable_facet(:imit) }
+
+    assert_equal [:json, :gwt, :gwt_rpc, :jpa, :imit], repository.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit], entity1.enabled_facets
+    assert_equal [:json, :gwt, :gwt_rpc, :jpa, :imit], entity2.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit], attribute1.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit], attribute2.enabled_facets
+
+    entity1.disable_facet(:gwt)
+
+    assert_equal [:json, :gwt, :gwt_rpc, :jpa, :imit], repository.enabled_facets
+    assert_equal [:jpa], entity1.enabled_facets
+    assert_equal [:json, :gwt, :gwt_rpc, :jpa, :imit], entity2.enabled_facets
+    assert_equal [:jpa], attribute1.enabled_facets
+    assert_equal [:jpa], attribute2.enabled_facets
+
+    entity1.enable_facet(:json)
+
+    assert_equal [:json, :gwt, :gwt_rpc, :jpa, :imit], repository.enabled_facets
+    assert_equal [:jpa, :json], entity1.enabled_facets
+    assert_equal [:json, :gwt, :gwt_rpc, :jpa, :imit], entity2.enabled_facets
+    assert_equal [:jpa, :json], attribute1.enabled_facets
+    assert_equal [:jpa, :json], attribute2.enabled_facets
+
+    repository.disable_facet(:json)
+
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit], repository.enabled_facets
+    assert_equal [:jpa], entity1.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit], entity2.enabled_facets
+    assert_equal [:jpa], attribute1.enabled_facets
+    assert_equal [:jpa], attribute2.enabled_facets
+
+    repository.enable_facets([:json])
+
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], repository.enabled_facets
+    assert_equal [:jpa, :json], entity1.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], entity2.enabled_facets
+    assert_equal [:jpa, :json], attribute1.enabled_facets
+    assert_equal [:jpa, :json], attribute2.enabled_facets
+
+    # No-op as all enabled
+    repository.enable_facets([:json])
+
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], repository.enabled_facets
+    assert_equal [:jpa, :json], entity1.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], entity2.enabled_facets
+    assert_equal [:jpa, :json], attribute1.enabled_facets
+    assert_equal [:jpa, :json], attribute2.enabled_facets
+
+    assert_raise_message('Facet json already enabled.') { repository.enable_facets!([:json]) }
+
+    # Try using brackets
+    repository.disable_facets([:json, :imit])
+    repository.enable_facets([:imit, :json])
+
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], repository.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], entity1.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], entity2.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], attribute1.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], attribute2.enabled_facets
+
+    # Try using raw facet list
+    repository.disable_facets(:json, :imit)
+    repository.enable_facets(:imit, :json)
+
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], repository.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], entity1.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], entity2.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], attribute1.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], attribute2.enabled_facets
+
+    # Try forcing
+    repository.disable_facets(:json, :imit)
+    repository.enable_facets!(:imit, :json)
+
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], repository.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], entity1.enabled_facets
+    assert_equal [:gwt, :gwt_rpc, :jpa, :imit, :json], entity2.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], attribute1.enabled_facets
+    assert_equal [:jpa, :gwt, :gwt_rpc, :imit, :json], attribute2.enabled_facets
+  end
+
+  def test_extension_point
+    TestFacetContainer.target_manager.target(Repository, :repository)
+    TestFacetContainer.target_manager.target(Entity, :entity, :repository)
+    TestFacetContainer.target_manager.target(Attribute, :attribute, :entity)
+
+    TestFacetContainer.facet(:json) do |f|
+      f.enhance(Entity) do
+        def hook2?
+          @hook2 ||= false
+        end
+
+        def hook2
+          @hook2 = true
+        end
+      end
+    end
+
+    TestFacetContainer.facet(:jpa) do |f|
+      f.enhance(Repository) do
+        def hook1?
+          @hook1 ||= false
+        end
+
+        def hook1
+          @hook1 = true
+        end
+
+        def hook2?
+          @hook2 ||= false
+        end
+
+        def hook2
+          @hook2 = true
+        end
+      end
+
+      f.enhance(Attribute) do
+        def hook2?
+          @hook2 ||= false
+        end
+
+        def hook2
+          @hook2 = true
+        end
+      end
+    end
+
+    repository = Repository.new(:MyRepo) do |r|
+      TestFacetContainer.target_manager.apply_extension(r)
+
+      r.enable_facets(:json, :jpa)
+
+      r.entity(:MyEntityA) do |e|
+        TestFacetContainer.target_manager.apply_extension(e)
+        e.disable_facet(:json)
+        e.attribute(:MyAttr1) do |a|
+          TestFacetContainer.target_manager.apply_extension(a)
+        end
+        e.attribute(:MyAttr2) do |a|
+          TestFacetContainer.target_manager.apply_extension(a)
+        end
+      end
+
+      r.entity(:MyEntityB) do |e|
+        TestFacetContainer.target_manager.apply_extension(e)
+      end
+    end
+
+    entity1 = repository.entities[0]
+    entity2 = repository.entities[1]
+    attribute1 = entity1.attributes[0]
+    attribute2 = entity1.attributes[1]
+
+    assert_equal false, repository.jpa.hook1?
+    assert_equal false, repository.jpa.hook2?
+    assert_equal false, entity2.json.hook2?
+    assert_equal false, attribute1.jpa.hook2?
+    assert_equal false, attribute2.jpa.hook2?
+
+    repository.send(:extension_point, :hook1)
+
+    assert_equal true, repository.jpa.hook1?
+    assert_equal false, repository.jpa.hook2?
+    assert_equal false, entity2.json.hook2?
+    assert_equal false, attribute1.jpa.hook2?
+    assert_equal false, attribute2.jpa.hook2?
+
+    repository.send(:extension_point, :hook2)
+
+    assert_equal true, repository.jpa.hook1?
+    assert_equal true, repository.jpa.hook2?
+    assert_equal true, entity2.json.hook2?
+    assert_equal true, attribute1.jpa.hook2?
+    assert_equal true, attribute2.jpa.hook2?
+  end
+end