reality-generators 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9ad0b0940ce5ac12939a1a706dc9ad33bcc11dc
-  data.tar.gz: eb2a63bbafeb93019936dbe82e04be952267484d
+  metadata.gz: fd884c4080b180702c66c240bc3782989c7e0533
+  data.tar.gz: 80120fc316eb2ab3136c5be04e4f7f359afac81d
 SHA512:
-  metadata.gz: 6bec7f97ecedf32f57af104a8b759b8236c7aaeb7dd56062854632462792918752040c0c218c80fba42f0eabaf35a7c64db7b9eee048a56d79f7d302afcfb385
-  data.tar.gz: 6a8d123251caaccd2f19e200ef26772402a3bed3d95f8ff9d234b0997003311238cead078c4edd6eff99912bbf0d3d63c09b757a131c86ec480fe44f39ef92a2
+  metadata.gz: 749439d7af5d2316f8b22960c893a5b277ca074031e8c915e4dbfe7f5d18c2d99600dcaeee9344d5a5ba2a2d7d3c7d9d6c70b6ace3c59d0aefbc1765befded8c
+  data.tar.gz: 675da30cf2daa432a2e66cde10fb35a407ee7753eb9e2e0f92a32c96c7b863723ad312257df618cc6567c020829b35d7a1e49e45c00b985223efd6e4a46f0fd5

data/lib/reality/generators.rb

@@ -27,5 +27,7 @@ require 'reality/generators/erb_template'
 require 'reality/generators/template_set'
 require 'reality/generators/template_set_container'
 require 'reality/generators/generator'
+require 'reality/generators/standard_template_set'
+require 'reality/generators/standard_artifact_dsl'
 
 require 'reality/generators/buildr_integration'

data/lib/reality/generators/buildr_integration.rb

@@ -14,87 +14,89 @@
 
 module Reality #nodoc
   module Generators #nodoc
-    module Generator
-      # This method is called from a Rake or Buildr task to configure the Buildr
-      # project so that it knows the location of all the generated artifacts and
-      # adds them to the appropriate compile paths etc.
-      def configure_buildr_project(buildr_project, generator_task, templates, target_dir)
-        if buildr_project.nil?
-          task('clean') do
-            rm_rf target_dir
-          end
-        else
-          buildr_project.clean { rm_rf target_dir }
-          file(File.expand_path(target_dir) => [generator_task])
-
-          # Is there java source generated in project?
-          if templates.any? { |template| template.output_path =~ /^main\/java\/.*/ }
-            main_java_dir = "#{target_dir}/main/java"
-            file(main_java_dir => [generator_task]) do
-              mkdir_p main_java_dir
+    module Buildr
+      class << self
+        # This method is called from a Rake or Buildr task to configure the Buildr
+        # project so that it knows the location of all the generated artifacts and
+        # adds them to the appropriate compile paths etc.
+        def configure_buildr_project(buildr_project, generator_task, templates, target_dir)
+          if buildr_project.nil?
+            task('clean') do
+              rm_rf target_dir
             end
-            buildr_project.compile.using :javac
-            buildr_project.compile.from main_java_dir
-            # Need to force this as it may have already been cached and thus will not recalculate
-            buildr_project.iml.main_generated_source_directories << main_java_dir if buildr_project.iml?
-          end
+          else
+            buildr_project.clean { rm_rf target_dir }
+            file(File.expand_path(target_dir) => [generator_task])
 
-          # Is there resources generated in project?
-          if templates.any? { |template| template.output_path =~ /^main\/resources\/.*/ }
-            main_resources_dir = "#{target_dir}/main/resources"
-            file(main_resources_dir => [generator_task]) do
-              mkdir_p main_resources_dir
+            # Is there java source generated in project?
+            if templates.any? { |template| template.output_path =~ /^main\/java\/.*/ }
+              main_java_dir = "#{target_dir}/main/java"
+              file(main_java_dir => [generator_task]) do
+                mkdir_p main_java_dir
+              end
+              buildr_project.compile.using :javac
+              buildr_project.compile.from main_java_dir
+              # Need to force this as it may have already been cached and thus will not recalculate
+              buildr_project.iml.main_generated_source_directories << main_java_dir if buildr_project.iml?
             end
-            buildr_project.resources.enhance([generator_task])
-            buildr_project.resources.filter.into buildr_project.path_to(:target, :main, :resources) unless buildr_project.resources.target
-            buildr_project.resources do |t|
-              t.enhance do
-                if File.exist?(main_resources_dir)
-                  FileUtils.mkdir_p buildr_project.resources.target.to_s
-                  FileUtils.cp_r "#{main_resources_dir}/.", buildr_project.resources.target.to_s
+
+            # Is there resources generated in project?
+            if templates.any? { |template| template.output_path =~ /^main\/resources\/.*/ }
+              main_resources_dir = "#{target_dir}/main/resources"
+              file(main_resources_dir => [generator_task]) do
+                mkdir_p main_resources_dir
+              end
+              buildr_project.resources.enhance([generator_task])
+              buildr_project.resources.filter.into buildr_project.path_to(:target, :main, :resources) unless buildr_project.resources.target
+              buildr_project.resources do |t|
+                t.enhance do
+                  if File.exist?(main_resources_dir)
+                    FileUtils.mkdir_p buildr_project.resources.target.to_s
+                    FileUtils.cp_r "#{main_resources_dir}/.", buildr_project.resources.target.to_s
+                  end
                 end
               end
+              buildr_project.iml.main_generated_resource_directories << main_resources_dir if buildr_project.iml?
             end
-            buildr_project.iml.main_generated_resource_directories << main_resources_dir if buildr_project.iml?
-          end
 
-          # Is there assets generated in project?
-          if templates.any? { |template| template.output_path =~ /^main\/webapp\/.*/ }
-            webapp_dir = File.expand_path("#{target_dir}/main/webapp")
-            buildr_project.assets.enhance([generator_task])
-            buildr_project.assets.paths << file(webapp_dir => [generator_task]) do
-              mkdir_p webapp_dir
+            # Is there assets generated in project?
+            if templates.any? { |template| template.output_path =~ /^main\/webapp\/.*/ }
+              webapp_dir = File.expand_path("#{target_dir}/main/webapp")
+              buildr_project.assets.enhance([generator_task])
+              buildr_project.assets.paths << file(webapp_dir => [generator_task]) do
+                mkdir_p webapp_dir
+              end
             end
-          end
 
-          # Is there test java source generated in project?
-          if templates.any? { |template| template.output_path =~ /^test\/java\/.*/ }
-            test_java_dir = "#{target_dir}/test/java"
-            file(test_java_dir => [generator_task]) do
-              mkdir_p test_java_dir
+            # Is there test java source generated in project?
+            if templates.any? { |template| template.output_path =~ /^test\/java\/.*/ }
+              test_java_dir = "#{target_dir}/test/java"
+              file(test_java_dir => [generator_task]) do
+                mkdir_p test_java_dir
+              end
+              buildr_project.test.compile.from test_java_dir
+              # Need to force this as it may have already been cached and thus will not recalculate
+              buildr_project.iml.test_generated_source_directories << test_java_dir if buildr_project.iml?
             end
-            buildr_project.test.compile.from test_java_dir
-            # Need to force this as it may have already been cached and thus will not recalculate
-            buildr_project.iml.test_generated_source_directories << test_java_dir if buildr_project.iml?
-          end
 
-          # Is there resources generated in project?
-          if templates.any? { |template| template.output_path =~ /^test\/resources\/.*/ }
-            test_resources_dir = "#{target_dir}/test/resources"
-            file(test_resources_dir => [generator_task]) do
-              mkdir_p test_resources_dir
-            end
-            buildr_project.test.resources.enhance([generator_task])
-            buildr_project.test.resources.filter.into buildr_project.path_to(:target, :test, :resources) unless buildr_project.test.resources.target
-            buildr_project.test.resources do |t|
-              t.enhance do
-                if File.exist?(test_resources_dir)
-                  FileUtils.mkdir_p buildr_project.test.resources.target.to_s
-                  FileUtils.cp_r "#{test_resources_dir}/.", buildr_project.test.resources.target.to_s
+            # Is there resources generated in project?
+            if templates.any? { |template| template.output_path =~ /^test\/resources\/.*/ }
+              test_resources_dir = "#{target_dir}/test/resources"
+              file(test_resources_dir => [generator_task]) do
+                mkdir_p test_resources_dir
+              end
+              buildr_project.test.resources.enhance([generator_task])
+              buildr_project.test.resources.filter.into buildr_project.path_to(:target, :test, :resources) unless buildr_project.test.resources.target
+              buildr_project.test.resources do |t|
+                t.enhance do
+                  if File.exist?(test_resources_dir)
+                    FileUtils.mkdir_p buildr_project.test.resources.target.to_s
+                    FileUtils.cp_r "#{test_resources_dir}/.", buildr_project.test.resources.target.to_s
+                  end
                 end
               end
+              buildr_project.iml.test_generated_resource_directories << test_resources_dir if buildr_project.iml?
             end
-            buildr_project.iml.test_generated_resource_directories << test_resources_dir if buildr_project.iml?
           end
         end
       end

data/lib/reality/generators/generator.rb

@@ -14,11 +14,18 @@
 
 module Reality #nodoc
   module Generators #nodoc
-    module Generator
+    class Generator
+
+      def initialize(template_set_container)
+        @template_set_container = template_set_container
+      end
+
+      attr_reader :template_set_container
+
       # Return a list of templates loaded from specified template_set_keys
-      def load_templates_from_template_sets(template_set_container, template_set_keys)
+      def load_templates_from_template_sets(template_set_keys)
         template_map = {}
-        load_templates(template_set_container, template_map, template_set_keys, [])
+        load_templates(template_map, template_set_keys, [])
         template_map.values
       end
 
@@ -29,13 +36,13 @@ module Reality #nodoc
       # The traversal starts from a root element of specified element_type and
       # traverses all elements that are contained transitively by the root element.
       # The templates then generate files from traversed elements.
-      def generate(template_set_container, element_type, element, directory, templates, filter)
+      def generate(element_type, element, directory, templates, filter)
         unprocessed_files = (Dir["#{directory}/**/*.*"] + Dir["#{directory}/**/*"]).uniq
 
         Generators.debug "Templates to process: #{templates.collect { |t| t.name }.inspect}"
 
         targets = {}
-        collect_generation_targets(template_set_container, element_type, element, element, targets)
+        collect_generation_targets(element_type, element, element, targets)
 
         templates.each do |template|
           Generators.debug "Evaluating template: #{template.name}"
@@ -66,12 +73,12 @@ module Reality #nodoc
 
       private
 
-      def load_templates(template_set_container, template_map, template_set_keys, processed_template_sets)
+      def load_templates(template_map, template_set_keys, processed_template_sets)
         template_set_keys.each do |template_set_key|
           next if processed_template_sets.include?(template_set_key)
-          template_set = template_set_container.template_set_by_name(template_set_key)
+          template_set = self.template_set_container.template_set_by_name(template_set_key)
           processed_template_sets << template_set_key
-          load_templates(template_set_container, template_map, template_set.required_template_sets, processed_template_sets)
+          load_templates(template_map, template_set.required_template_sets, processed_template_sets)
           template_set.templates.each do |template|
             template_map[template.name] = template
           end
@@ -92,11 +99,11 @@ module Reality #nodoc
       #   ...
       # }
       #
-      def collect_generation_targets(template_set_container, element_type, scope_element, element, targets)
+      def collect_generation_targets(element_type, scope_element, element, targets)
         (targets[element_type] ||= []) << [scope_element, element]
 
-        template_set_container.target_manager.targets_by_container(element_type).each do |target|
-          next unless handle_subelement?(element, target.key)
+        self.template_set_container.target_manager.targets_by_container(element_type).each do |target|
+          next unless self.template_set_container.handle_subelement?(element, target.key)
           subelements = nil
           subscope = nil
           if target.standard?
@@ -110,16 +117,10 @@ module Reality #nodoc
           subelements = [subelements] unless subelements.is_a?(Array)
 
           subelements.each do |subelement|
-            collect_generation_targets(template_set_container, target.qualified_key, subscope || subelement, subelement, targets)
+            collect_generation_targets(target.qualified_key, subscope || subelement, subelement, targets)
           end
         end
       end
-
-      # A hook to control whether certain paths in model should
-      # be follow when collecting generation targets
-      def handle_subelement?(object, sub_feature_key)
-        true
-      end
     end
   end
 end

data/lib/reality/generators/standard_artifact_dsl.rb

@@ -0,0 +1,121 @@
+#
+# 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 Generators #nodoc
+
+    # This module is typically included into the facet extension objects. It
+    # simplifies the definition of templates from the facet extension objects.
+    #
+    # Note: The framework needs to supply a method template_set_container
+    #
+    # The module assumes that facets are defined using a specific convention.
+    # Namely that by convention facets are defined in a file named `.../<myfacet>/model.rb`
+    # and templates are defined in a file named `.../<myfacet>/templates/<templatekey>.<output_extension>.<template_extension>`
+    # When attempting to derive default values for configuration it will be derived using these conventions.
+    #
+    module ArtifactDSL
+
+      #
+      # Define a java artifact. This is a wrapper around the artifact() method
+      # that makes additional assumptions for java based artifacts. This method
+      # assumes a maven-style file system layout (i.e. java is stored in main/java or test/java).
+      # It also assumes that the facet has the fully qualified name of the artifact in a method
+      # named with the convention "qualified_<artifact_key>_name"
+      #
+      # The options supported include those supplied to the artifact method plus:
+      # * :artifact_category - The option must be one of :main or :test and determines which source hierarchy the code is added to.
+      #
+      def java_artifact(template_set_suffix, artifact_key, options = {})
+        options = options.dup
+        artifact_category = options.delete(:artifact_category) || :main
+        Reality::Generators.error("artifact_category '#{artifact_category}' is not a known type") unless [:main, :test].include?(artifact_category)
+        filename_pattern = "#{artifact_category}/java/\#{#{self.target_key}.#{self.facet_key}.qualified_#{artifact_key}_name.gsub(\".\",\"/\")}.java"
+        artifact(template_set_suffix, artifact_key, filename_pattern, options)
+      end
+
+      #
+      # Define an artifact and attach it to template_set.
+      # This assumes that the the template is named with the convention "<facet_templates_directory>/<artifact_key>.<file_extension>"
+      # with the file extension derived from the supplied filename pattern.
+      #
+      # The template set is prefixed with the name of the facet from which this is extended.
+      #
+      # The options supported include:
+      # * :facets - additional facets that must be enabled for the facet to be generated.
+      # * :helpers - additional helpers that are added to the default helpers.
+      # * :guard - The :guard option passed to the template.
+      #
+      def artifact(template_set_suffix, artifact_key, filename_pattern, options = {})
+        Reality::Options.check(options, [:facets, :guard, :helpers], Reality::Generators, 'define artifact')
+
+        facets = [self.facet_key] + (options[:facets].nil? ? [] : options[:facets])
+
+        guard = options[:guard]
+
+        artifact_type = self.target_key
+
+        template_set_key = :"#{self.facet_key}_#{template_set_suffix}"
+
+        file_extension = File.extname(filename_pattern)[1...9999]
+
+        template_set = template_set_container.template_set_by_name?(template_set_key) ?
+          template_set_container.template_set_by_name(template_set_key) :
+          template_set_container.template_set(template_set_key)
+
+        base_template_filename = "#{facet_templates_directory}/#{artifact_key}.#{file_extension}"
+        template_extension = File.exist?("#{base_template_filename}.erb") ? 'erb' : 'rb'
+        template_filename = "#{base_template_filename}.#{template_extension}"
+
+
+        helpers = template_set_container.derive_default_helpers(options.merge(:file_type => file_extension, :artifact_type => artifact_type, :facet_key => self.facet_key)) +
+                  (options[:helpers].nil? ? [] : options[:helpers])
+
+        if 'erb' == template_extension
+          template_set.erb_template(facets,
+                                    artifact_type,
+                                    template_filename,
+                                    filename_pattern,
+                                    helpers,
+                                    :guard => guard)
+        else
+          template_set.ruby_template(facets,
+                                     artifact_type,
+                                     template_filename,
+                                     filename_pattern,
+                                     helpers,
+                                     :guard => guard)
+        end
+      end
+
+      def facet_templates_directory
+        @facet_templates_directory ||= "#{facet_directory}/templates"
+      end
+
+      def facet_directory
+        @facet_directory ||= nil
+        if @facet_directory.nil?
+          caller_locations.each do |location|
+            if location.absolute_path =~ /.*\/#{self.facet_key}\/model\.rb$/
+              @facet_directory = File.dirname(location.absolute_path)
+              break
+            end
+          end
+          Reality::Generators.error("Unable to locate facet_directory for facet #{self.facet_key}. Caller trace: #{caller_locations.collect{|c|c.absolute_path}.inspect}") if @facet_directory.nil?
+        end
+        @facet_directory
+      end
+    end
+  end
+end

data/lib/reality/generators/standard_template_set.rb

@@ -0,0 +1,29 @@
+#
+# 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 Generators #nodoc
+
+    # A standard template set that simple methods for creating templates using included template types
+    class StandardTemplateSet < TemplateSet
+      def erb_template(facets, target, template_filename, output_filename_pattern, helpers = [], options = {})
+        Reality::Generators::ErbTemplate.new(self, facets, target.to_sym, template_filename, output_filename_pattern, helpers, options)
+      end
+
+      def ruby_template(facets, target, template_filename, output_filename_pattern, helpers = [], options = {})
+        Reality::Generators::RubyTemplate.new(self, facets, target.to_sym, template_filename, output_filename_pattern, helpers, options)
+      end
+    end
+  end
+end

data/lib/reality/generators/target_manager.rb

@@ -26,7 +26,7 @@ module Reality #nodoc
         @container_key = container_key.nil? ? nil : container_key.to_sym
 
         if @container_key && !target_manager.target_by_key?(@container_key)
-          raise "Target '#{key}' defines container as '#{@container_key}' but no such target exists."
+          Reality::Generators.error("Target '#{key}' defines container as '#{@container_key}' but no such target exists.")
         end
 
         @target_manager.send(:register_target, self)
@@ -69,7 +69,7 @@ module Reality #nodoc
 
       def target_by_key(key)
         target = target_map[key.to_sym]
-        raise "Can not find target with key '#{key}'" unless target
+        Reality::Generators.error("Can not find target with key '#{key}'") unless target
         target
       end
 
@@ -88,7 +88,7 @@ module Reality #nodoc
       private
 
       def register_target(target)
-        raise "Attempting to redefine target #{target.qualified_key}" if target_map[target.qualified_key]
+        Reality::Generators.error("Attempting to redefine target #{target.qualified_key}") if target_map[target.qualified_key]
         target_map[target.qualified_key] = target
       end
 

data/lib/reality/generators/template.rb

@@ -71,7 +71,7 @@ module Reality #nodoc
       end
 
       def name
-        @name ||= "#{self.template_set.name}:#{self.template_key.gsub(/.*\/templates\/(.*)\.#{template_extension}$/, '\1')}"
+        @name ||= "#{self.template_set.name}:#{self.template_key.gsub(/^(.*\/)?templates\/(.*)\.#{template_extension}$/, '\2')}"
       end
 
       protected

data/lib/reality/generators/template_set.rb

@@ -29,7 +29,7 @@ module Reality #nodoc
         super(options, &block)
         self.required_template_sets.each do |template_set_name|
           unless container.template_set_by_name?(template_set_name)
-            raise "TemplateSet '#{self.name}' defined requirement on template set '#{template_set_name}' that does not exist."
+            Reality::Generators.error("TemplateSet '#{self.name}' defined requirement on template set '#{template_set_name}' that does not exist.")
           end
         end
         container.send(:register_template_set, self)

data/lib/reality/generators/template_set_container.rb

@@ -45,18 +45,31 @@ module Reality #nodoc
       end
 
       def generator
-        @generator ||= new_generator
+        @generator ||= Reality::Generators::Generator.new(self)
+      end
+
+      # A hook to control whether certain paths in model should
+      # be follow when collecting generation targets
+      def handle_subelement?(object, sub_feature_key)
+        true
+      end
+
+      # Hook for deriving the default set of helpers when defining
+      # templates using the artifact DSL. Typically this is overridden
+      # in framework specific template set containers
+      def derive_default_helpers(options)
+        []
       end
 
       protected
 
       def register_template_set(template_set)
-        raise "Attempting to redefine template_set #{template_set.name}" if template_set_map[template_set.name.to_s]
+        Reality::Generators.error("Attempting to redefine template_set #{template_set.name}") if template_set_map[template_set.name.to_s]
         template_set_map[template_set.name.to_s] = template_set
       end
 
       def new_template_set(name, options, &block)
-        Generators.error('new_template_set not implemented')
+        Reality::Generators::StandardTemplateSet.new(self, name.to_s, options, &block)
       end
 
       def new_generator

data/reality-generators.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name               = %q{reality-generators}
-  s.version            = '1.3.0'
+  s.version            = '1.5.0'
   s.platform           = Gem::Platform::RUBY
 
   s.authors            = ['Peter Donald']
@@ -21,8 +21,8 @@ Gem::Specification.new do |s|
   s.has_rdoc           = false
   s.rdoc_options       = %w(--line-numbers --inline-source --title reality-generators)
 
-  s.add_dependency 'reality-core', '>= 1.4.0'
-  s.add_dependency 'reality-naming', '>= 1.4.0'
+  s.add_dependency 'reality-core', '>= 1.7.0'
+  s.add_dependency 'reality-naming', '>= 1.6.0'
   s.add_dependency 'reality-orderedhash', '>= 1.0.0'
 
   s.add_development_dependency(%q<minitest>, ['= 5.9.1'])

data/test/generators/jpa/model.rb

@@ -0,0 +1,63 @@
+class TestFacetExtension
+  module MyHelperModule
+  end
+
+  class << self
+    include Reality::Generators::ArtifactDSL
+
+    def template_set_container
+      Reality::TestCase::TestTemplateSetContainer
+    end
+
+    def target_key
+      :entity
+    end
+
+    def facet_key
+      :jpa
+    end
+
+    def define_artifacts1
+      artifact(:models, :mytemplate, 'main/java/#{entity.qualified_name}.java')
+    end
+
+    def define_artifacts2
+      artifact(:models, :rubytemplate, 'main/java/#{entity.qualified_name}.java')
+    end
+
+    def define_artifacts3
+      artifact(:models,
+               :mytemplate,
+               'main/java/#{entity.qualified_name}.java',
+               :facets => [:ee],
+               :helpers => [MyHelperModule],
+               :guard => 'entity.jpa.good?')
+    end
+
+    def define_artifacts4
+      artifact(:models, :mytemplate, 'main/java/#{entity.qualified_name}.java')
+    end
+
+    def define_artifacts5
+      artifact(:models, :mytemplate, 'main/java/#{entity.qualified_name}.java')
+      artifact(:qa_models, :mytemplate, 'test/java/#{entity.qualified_name}.java')
+      artifact(:qa_models, :rubytemplate, 'main/java/#{entity.qualified_name}.java')
+    end
+
+    def define_artifacts6
+      artifact(:models, :mytemplate, 'main/java/#{entity.qualified_name}.java', :bad_option => true)
+    end
+
+    def define_artifacts7
+      java_artifact(:models, :mytemplate)
+    end
+
+    def define_artifacts8
+      java_artifact(:models, :mytemplate, :artifact_category => :test)
+    end
+
+    def define_artifacts9
+      java_artifact(:models, :mytemplate, :artifact_category => :main)
+    end
+  end
+end

data/test/generators/test_erb_template.rb

@@ -16,7 +16,7 @@ class Reality::Generators::TestErbTemplate < Reality::TestCase
     template_set = Reality::Generators::TemplateSet.new(TestTemplateSetContainer, 'foo')
 
     output_filename_pattern = 'main/java/#{component.name}.java'
-    template_filename = File.expand_path(File.dirname(__FILE__) + '/templates/mytemplate.java.erb')
+    template_filename = File.expand_path(File.dirname(__FILE__) + '/jpa/templates/mytemplate.java.erb')
     TestTemplateSetContainer.target_manager.target(:component)
 
     template1 = Reality::Generators::ErbTemplate.new(template_set, [], :component, template_filename, output_filename_pattern, [], {})

data/test/generators/test_generator.rb

@@ -59,11 +59,11 @@ class Reality::Generators::TestGenerator < Reality::TestCase
     end
 
     def facet_enabled?(facet)
-      facet == :jpa ? !!@jpa : false
+      facet == :jpa ? !!self.jpa : false
     end
 
     def jpa
-      @jpa
+      @jpa ||= nil
     end
 
     def enable_jpa!
@@ -90,7 +90,7 @@ class Reality::Generators::TestGenerator < Reality::TestCase
     TestTemplateSetContainer.target_manager.target(:unit, :repository, :facet_key => :jpa)
 
     targets = {}
-    TestTemplateSetContainer.generator.send(:collect_generation_targets, TestTemplateSetContainer, :repository, repository, repository, targets)
+    TestTemplateSetContainer.generator.send(:collect_generation_targets, :repository, repository, repository, targets)
 
     assert_equal true, targets.include?(:repository)
     assert_equal true, targets.include?(:entity)
@@ -119,7 +119,7 @@ class Reality::Generators::TestGenerator < Reality::TestCase
     repository.enable_jpa!
 
     targets = {}
-    TestTemplateSetContainer.generator.send(:collect_generation_targets, TestTemplateSetContainer, :repository, repository, repository, targets)
+    TestTemplateSetContainer.generator.send(:collect_generation_targets, :repository, repository, repository, targets)
 
     # No units have been defined so no extra targets
     assert_equal 3, targets.size
@@ -128,7 +128,7 @@ class Reality::Generators::TestGenerator < Reality::TestCase
     repository.jpa.unit(:MyUnit2)
 
     targets = {}
-    TestTemplateSetContainer.generator.send(:collect_generation_targets, TestTemplateSetContainer, :repository, repository, repository, targets)
+    TestTemplateSetContainer.generator.send(:collect_generation_targets, :repository, repository, repository, targets)
 
     assert_equal true, targets.include?(:repository)
     assert_equal true, targets.include?(:entity)
@@ -189,12 +189,12 @@ class Reality::Generators::TestGenerator < Reality::TestCase
     TestTemplateSetContainer.target_manager.target(:attribute, :entity)
     TestTemplateSetContainer.target_manager.target(:unit, :repository, :facet_key => :jpa)
 
-    template_set = TestTemplateSetContainer.template_set(:test) do |template_set|
-      RepositoryTemplate.new(template_set, [], :repository, 'repository.java', 'main/java/#{repository.name}.java')
+    template_set = TestTemplateSetContainer.template_set(:test) do |t|
+      RepositoryTemplate.new(t, [], :repository, 'repository.java', 'main/java/#{repository.name}.java')
 
-      EntityTemplate.new(template_set, [], :entity, 'entity.java', 'main/java/#{entity.qualified_name.gsub(".","/")}.java', [], :guard => 'entity.qualified_name == "MyRepo.MyEntityB"')
-      AttributeTemplate.new(template_set, [], :attribute, 'attribute.java', 'main/java/#{attribute.qualified_name.gsub(".","/")}.java')
-      UnitTemplate.new(template_set, [], :'jpa.unit', 'unit.java', 'main/java/units/#{unit.name.gsub(".","/")}.java', [], {})
+      EntityTemplate.new(t, [], :entity, 'entity.java', 'main/java/#{entity.qualified_name.gsub(".","/")}.java', [], :guard => 'entity.qualified_name == "MyRepo.MyEntityB"')
+      AttributeTemplate.new(t, [], :attribute, 'attribute.java', 'main/java/#{attribute.qualified_name.gsub(".","/")}.java')
+      UnitTemplate.new(t, [], :'jpa.unit', 'unit.java', 'main/java/units/#{unit.name.gsub(".","/")}.java', [], {})
     end
 
     target_directory = "#{temp_dir}/generated/erb_template"
@@ -211,7 +211,7 @@ class Reality::Generators::TestGenerator < Reality::TestCase
 
     filter = Proc.new { |artifact_type, artifact| artifact_type != :attribute || %w(MyAttr1 MyAttr2).include?(artifact.name.to_s) }
     TestTemplateSetContainer.generator.
-      generate(TestTemplateSetContainer, :repository, repository, target_directory, template_set.templates, filter)
+      generate(:repository, repository, target_directory, template_set.templates, filter)
 
     assert_equal false, File.directory?("#{target_directory}/some")
     assert_equal false, File.exist?("#{target_directory}/main/java/Touched.java")
@@ -269,8 +269,7 @@ class Reality::Generators::TestGenerator < Reality::TestCase
     end
 
     template_set_keys = [:template_set_1, :template_set_4]
-    templates = TestTemplateSetContainer.generator.
-      load_templates_from_template_sets(TestTemplateSetContainer, template_set_keys)
+    templates = TestTemplateSetContainer.generator.load_templates_from_template_sets(template_set_keys)
 
     assert_equal 6, templates.size
     assert_equal %w(template_set_1:attribute.java template_set_1:entity.java template_set_1:repository1.java template_set_1:unit.java template_set_4:attribute4.java template_set_4:repository4.java),

data/test/generators/test_ruby_template.rb

@@ -16,7 +16,7 @@ class Reality::Generators::TestRubyTemplate < Reality::TestCase
     template_set = Reality::Generators::TemplateSet.new(TestTemplateSetContainer, 'foo')
 
     output_filename_pattern = 'main/java/#{component.name}.java'
-    template_filename = File.expand_path(File.dirname(__FILE__) + '/templates/rubytemplate.rb')
+    template_filename = File.expand_path(File.dirname(__FILE__) + '/jpa/templates/rubytemplate.java.rb')
     TestTemplateSetContainer.target_manager.target(:component)
 
     template1 = Reality::Generators::RubyTemplate.new(template_set, [], :component, template_filename, output_filename_pattern, [], {})
@@ -30,7 +30,7 @@ class Reality::Generators::TestRubyTemplate < Reality::TestCase
     assert_equal template_filename, template1.template_key
     assert_equal nil, template1.guard
     assert_equal({}, template1.extra_data)
-    assert_equal 'foo:rubytemplate', template1.name
+    assert_equal 'foo:rubytemplate.java', template1.name
 
     target_basedir = "#{temp_dir}/generated/ruby_template"
     target_filename = "#{target_basedir}/main/java/SimpleModel.java"

data/test/generators/test_standard_artifact_dsl.rb

@@ -0,0 +1,216 @@
+require File.expand_path('../../helper', __FILE__)
+require File.expand_path('../jpa/model', __FILE__)
+
+class Reality::Generators::TestStandardArtifactDSL < Reality::TestCase
+  def test_artifact_with_erb_template
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    TestFacetExtension.define_artifacts1
+
+    assert_equal TestTemplateSetContainer.template_sets.size, 1
+
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_models), true
+
+    template_set = TestTemplateSetContainer.template_set_by_name(:jpa_models)
+
+    assert_equal true, template_set.template_by_name?('jpa_models:mytemplate.java')
+
+    mytemplate = template_set.template_by_name('jpa_models:mytemplate.java')
+
+    assert_equal mytemplate.name, 'jpa_models:mytemplate.java'
+    assert_equal mytemplate.output_filename_pattern, 'main/java/#{entity.qualified_name}.java'
+    assert_equal template_set, mytemplate.template_set
+    assert_equal [:jpa], mytemplate.facets
+    assert_equal :entity, mytemplate.target
+    assert_equal [], mytemplate.helpers
+    assert_equal File.expand_path("#{File.dirname(__FILE__)}/jpa/templates/mytemplate.java.erb"), mytemplate.template_key
+    assert_equal nil, mytemplate.guard
+    assert_equal({}, mytemplate.extra_data)
+  end
+
+  def test_artifact_with_ruby_template
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    TestFacetExtension.define_artifacts2
+
+    assert_equal TestTemplateSetContainer.template_sets.size, 1
+
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_models), true
+
+    template_set = TestTemplateSetContainer.template_set_by_name(:jpa_models)
+
+    assert_equal true, template_set.template_by_name?('jpa_models:rubytemplate.java')
+
+    mytemplate = template_set.template_by_name('jpa_models:rubytemplate.java')
+
+    assert_equal mytemplate.name, 'jpa_models:rubytemplate.java'
+    assert_equal mytemplate.output_filename_pattern, 'main/java/#{entity.qualified_name}.java'
+    assert_equal template_set, mytemplate.template_set
+    assert_equal [:jpa], mytemplate.facets
+    assert_equal :entity, mytemplate.target
+    assert_equal [], mytemplate.helpers
+    assert_equal File.expand_path("#{File.dirname(__FILE__)}/jpa/templates/rubytemplate.java.rb"), mytemplate.template_key
+    assert_equal nil, mytemplate.guard
+    assert_equal({}, mytemplate.extra_data)
+  end
+
+  def test_artifact_with_options
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    TestFacetExtension.define_artifacts3
+
+    assert_equal TestTemplateSetContainer.template_sets.size, 1
+
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_models), true
+
+    template_set = TestTemplateSetContainer.template_set_by_name(:jpa_models)
+
+    assert_equal true, template_set.template_by_name?('jpa_models:mytemplate.java')
+
+    mytemplate = template_set.template_by_name('jpa_models:mytemplate.java')
+
+    assert_equal mytemplate.name, 'jpa_models:mytemplate.java'
+    assert_equal mytemplate.output_filename_pattern, 'main/java/#{entity.qualified_name}.java'
+    assert_equal template_set, mytemplate.template_set
+    assert_equal [:jpa, :ee], mytemplate.facets
+    assert_equal :entity, mytemplate.target
+    assert_equal [TestFacetExtension::MyHelperModule], mytemplate.helpers
+    assert_equal File.expand_path("#{File.dirname(__FILE__)}/jpa/templates/mytemplate.java.erb"), mytemplate.template_key
+    assert_equal 'entity.jpa.good?', mytemplate.guard
+    assert_equal({}, mytemplate.extra_data)
+  end
+
+  def test_artifact_with_default_helpers
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    TestTemplateSetContainer.helpers = [TestFacetExtension::MyHelperModule]
+
+    TestFacetExtension.define_artifacts4
+
+    assert_equal TestTemplateSetContainer.template_sets.size, 1
+
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_models), true
+
+    template_set = TestTemplateSetContainer.template_set_by_name(:jpa_models)
+
+    assert_equal true, template_set.template_by_name?('jpa_models:mytemplate.java')
+
+    mytemplate = template_set.template_by_name('jpa_models:mytemplate.java')
+
+    assert_equal mytemplate.name, 'jpa_models:mytemplate.java'
+    assert_equal mytemplate.output_filename_pattern, 'main/java/#{entity.qualified_name}.java'
+    assert_equal template_set, mytemplate.template_set
+    assert_equal [:jpa], mytemplate.facets
+    assert_equal :entity, mytemplate.target
+    assert_equal [TestFacetExtension::MyHelperModule], mytemplate.helpers
+    assert_equal File.expand_path("#{File.dirname(__FILE__)}/jpa/templates/mytemplate.java.erb"), mytemplate.template_key
+    assert_equal nil, mytemplate.guard
+    assert_equal({}, mytemplate.extra_data)
+  end
+
+  def test_multiple_artifact_definitions
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    TestFacetExtension.define_artifacts5
+
+    assert_equal TestTemplateSetContainer.template_sets.size, 2
+
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_models), true
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_qa_models), true
+
+    template_set1 = TestTemplateSetContainer.template_set_by_name(:jpa_models)
+    assert_equal 1, template_set1.templates.size
+    assert_equal true, template_set1.template_by_name?('jpa_models:mytemplate.java')
+
+    template_set2 = TestTemplateSetContainer.template_set_by_name(:jpa_qa_models)
+    assert_equal 2, template_set2.templates.size
+    assert_equal true, template_set2.template_by_name?('jpa_qa_models:mytemplate.java')
+    assert_equal true, template_set2.template_by_name?('jpa_qa_models:rubytemplate.java')
+  end
+
+  def test_artifact_bad_option
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    assert_generator_error("Unknown option ':bad_option' passed to define artifact") do
+      TestFacetExtension.define_artifacts6
+    end
+  end
+
+  def test_java_artifact
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    TestFacetExtension.define_artifacts7
+
+    assert_equal TestTemplateSetContainer.template_sets.size, 1
+
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_models), true
+
+    template_set = TestTemplateSetContainer.template_set_by_name(:jpa_models)
+
+    assert_equal true, template_set.template_by_name?('jpa_models:mytemplate.java')
+
+    mytemplate = template_set.template_by_name('jpa_models:mytemplate.java')
+
+    assert_equal mytemplate.name, 'jpa_models:mytemplate.java'
+    assert_equal mytemplate.output_filename_pattern, 'main/java/#{entity.jpa.qualified_mytemplate_name.gsub(".","/")}.java'
+    assert_equal template_set, mytemplate.template_set
+    assert_equal [:jpa], mytemplate.facets
+    assert_equal :entity, mytemplate.target
+    assert_equal [], mytemplate.helpers
+    assert_equal File.expand_path("#{File.dirname(__FILE__)}/jpa/templates/mytemplate.java.erb"), mytemplate.template_key
+    assert_equal nil, mytemplate.guard
+    assert_equal({}, mytemplate.extra_data)
+  end
+
+  def test_test_java_artifact
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    TestFacetExtension.define_artifacts8
+
+    assert_equal TestTemplateSetContainer.template_sets.size, 1
+
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_models), true
+
+    template_set = TestTemplateSetContainer.template_set_by_name(:jpa_models)
+
+    assert_equal true, template_set.template_by_name?('jpa_models:mytemplate.java')
+
+    mytemplate = template_set.template_by_name('jpa_models:mytemplate.java')
+
+    assert_equal mytemplate.name, 'jpa_models:mytemplate.java'
+    assert_equal mytemplate.output_filename_pattern, 'test/java/#{entity.jpa.qualified_mytemplate_name.gsub(".","/")}.java'
+    assert_equal template_set, mytemplate.template_set
+    assert_equal [:jpa], mytemplate.facets
+    assert_equal :entity, mytemplate.target
+    assert_equal [], mytemplate.helpers
+    assert_equal File.expand_path("#{File.dirname(__FILE__)}/jpa/templates/mytemplate.java.erb"), mytemplate.template_key
+    assert_equal nil, mytemplate.guard
+    assert_equal({}, mytemplate.extra_data)
+  end
+
+  def test_main_java_artifact
+    TestTemplateSetContainer.target_manager.target(:entity)
+
+    TestFacetExtension.define_artifacts9
+
+    assert_equal TestTemplateSetContainer.template_sets.size, 1
+
+    assert_equal TestTemplateSetContainer.template_set_by_name?(:jpa_models), true
+
+    template_set = TestTemplateSetContainer.template_set_by_name(:jpa_models)
+
+    assert_equal true, template_set.template_by_name?('jpa_models:mytemplate.java')
+
+    mytemplate = template_set.template_by_name('jpa_models:mytemplate.java')
+
+    assert_equal mytemplate.name, 'jpa_models:mytemplate.java'
+    assert_equal mytemplate.output_filename_pattern, 'main/java/#{entity.jpa.qualified_mytemplate_name.gsub(".","/")}.java'
+    assert_equal template_set, mytemplate.template_set
+    assert_equal [:jpa], mytemplate.facets
+    assert_equal :entity, mytemplate.target
+    assert_equal [], mytemplate.helpers
+    assert_equal File.expand_path("#{File.dirname(__FILE__)}/jpa/templates/mytemplate.java.erb"), mytemplate.template_key
+    assert_equal nil, mytemplate.guard
+    assert_equal({}, mytemplate.extra_data)
+  end
+end

data/test/generators/test_standard_template_set.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../helper', __FILE__)
+
+class Reality::Generators::TestStandardTemplateSet < Reality::TestCase
+  def test_template_set
+    TestTemplateSetContainer.target_manager.target(:component)
+
+    template_set =
+      Reality::Generators::StandardTemplateSet.new(TestTemplateSetContainer,
+                                                   :iris_entity,
+                                                   :description => 'Templates that generate iris entities') do |t|
+
+        t.erb_template([], :component, 'jpa/templates/mytemplate.java.erb', 'src/main/#{component.name}')
+        t.ruby_template([], :component, 'jpa/templates/rubytemplate.java.rb', 'src/main/#{component.name}2')
+      end
+
+
+    assert_equal :iris_entity, template_set.name
+    assert_equal [], template_set.required_template_sets
+    assert_equal 2, template_set.templates.size
+    assert_equal 'Templates that generate iris entities', template_set.description
+    assert_equal true, template_set.template_by_name?('iris_entity:rubytemplate.java')
+    assert_equal true, template_set.template_by_name?('iris_entity:mytemplate.java')
+  end
+end

data/test/generators/test_target_manager.rb

@@ -49,9 +49,9 @@ class Reality::Generators::TestTargetManager < Reality::TestCase
     assert_equal nil, target1.facet_key
     assert_equal true, target1.standard?
 
-    assert_raise_message('Attempting to redefine target project') { Reality::Generators::Target.new(target_manager, :project, nil, {}) }
+    assert_generator_error('Attempting to redefine target project') { Reality::Generators::Target.new(target_manager, :project, nil, {}) }
 
-    assert_raise_message("Target 'foo' defines container as 'bar' but no such target exists.") { Reality::Generators::Target.new(target_manager, :foo, :bar, {}) }
+    assert_generator_error("Target 'foo' defines container as 'bar' but no such target exists.") { Reality::Generators::Target.new(target_manager, :foo, :bar, {}) }
   end
 
   def test_target_manager_basic_operation
@@ -84,6 +84,6 @@ class Reality::Generators::TestTargetManager < Reality::TestCase
     assert_equal 1, target_manager.targets_by_container(:project).size
     assert_equal :component, target_manager.targets_by_container(:project)[0].key
 
-    assert_raise_message("Can not find target with key 'foo'") { target_manager.target_by_key(:foo) }
+    assert_generator_error("Can not find target with key 'foo'") { target_manager.target_by_key(:foo) }
   end
 end

data/test/generators/test_template.rb

@@ -64,12 +64,12 @@ class Reality::Generators::TestTemplate < Reality::TestCase
     name = 'Foo'
     options = {:guard => guard, :name => name, :extra_data => extra_data}
 
-    assert_raise_message('Unexpected facets: "X"') {
+    assert_generator_error('Unexpected facets: "X"') do
       Reality::Generators::Template.new(template_set, 'X', target, template_key, helpers, options)
-    }
-    assert_raise_message("Unknown target 'component' for template 'someMagicKey'. Valid targets include: ") {
+    end
+    assert_generator_error("Unknown target 'component' for template 'someMagicKey'. Valid targets include: ") do
       Reality::Generators::Template.new(template_set, facets, target, template_key, helpers, options)
-    }
+    end
 
     TestTemplateSetContainer.target_manager.target(target)
 
@@ -85,7 +85,7 @@ class Reality::Generators::TestTemplate < Reality::TestCase
     assert_equal name, template1.name
     assert_equal name, template1.to_s
 
-    assert_raise_message('output_path unimplemented') { template1.output_path }
+    assert_generator_error('output_path unimplemented') { template1.output_path }
 
     render_context = template1.send(:create_context, 'SomeValue')
 
@@ -116,6 +116,10 @@ class Reality::Generators::TestTemplate < Reality::TestCase
   end
 
   class StringTemplate < Reality::Generators::SingleFileOutputTemplate
+    def template_extension
+      'erb'
+    end
+
     def render_to_string(context_binding)
       'X'
     end
@@ -125,7 +129,7 @@ class Reality::Generators::TestTemplate < Reality::TestCase
     template_set = Reality::Generators::TemplateSet.new(TestTemplateSetContainer, 'foo')
 
     output_filename_pattern = 'main/java/#{component.name}.java'
-    template_key = 'MyFiles/templates/foo.erb.java'
+    template_key = 'MyFiles/templates/foo.java.erb'
     TestTemplateSetContainer.target_manager.target(:component)
 
     template1 = StringTemplate.new(template_set, [], :component, template_key, output_filename_pattern, [], {})
@@ -139,7 +143,7 @@ class Reality::Generators::TestTemplate < Reality::TestCase
     assert_equal template_key, template1.template_key
     assert_equal nil, template1.guard
     assert_equal({}, template1.extra_data)
-    assert_equal 'foo:MyFiles/templates/foo.erb.java', template1.name
+    assert_equal 'foo:foo.java', template1.name
 
     target_basedir = "#{temp_dir}/generated/single_file_template"
     target_filename = "#{target_basedir}/main/java/SimpleModel.java"

data/test/generators/test_template_set.rb

@@ -4,11 +4,11 @@ class Reality::Generators::TestTemplateSet < Reality::TestCase
   def test_template_set
     TestTemplateSetContainer.target_manager.target(:component)
 
-    assert_raise_message("TemplateSet 'iris_entity' defined requirement on template set 'iris_shared' that does not exist.") {
+    assert_generator_error("TemplateSet 'iris_entity' defined requirement on template set 'iris_shared' that does not exist.") do
       Reality::Generators::TemplateSet.new(TestTemplateSetContainer,
                                            :iris_entity,
                                            :required_template_sets => [:iris_shared])
-    }
+    end
 
     template_set1 = Reality::Generators::TemplateSet.new(TestTemplateSetContainer, :iris_shared)
 
@@ -31,7 +31,7 @@ class Reality::Generators::TestTemplateSet < Reality::TestCase
     template = Reality::Generators::ErbTemplate.new(template_set2,
                                                     [],
                                                     :component,
-                                                    'templates/mytemplate.java.erb',
+                                                    'jpa/templates/mytemplate.java.erb',
                                                     'src/main/#{component.name}',
                                                     [],
                                                     {})
@@ -39,15 +39,14 @@ class Reality::Generators::TestTemplateSet < Reality::TestCase
     assert_equal true, template_set2.template_by_name?(template.name)
     assert_equal template, template_set2.template_by_name(template.name)
 
-    assert_raise_message('Template already exists with specified name iris_entity:templates/mytemplate.java.erb') {
+    assert_generator_error('Template already exists with specified name iris_entity:mytemplate.java') do
       Reality::Generators::ErbTemplate.new(template_set2,
                                            [],
                                            :component,
-                                           'templates/mytemplate.java.erb',
+                                           'jpa/templates/mytemplate.java.erb',
                                            'src/main/#{component.name}',
                                            [],
                                            {})
-    }
-
+    end
   end
 end

data/test/generators/test_template_set_container.rb

@@ -4,13 +4,13 @@ class Reality::Generators::TestTemplateSetContainer < Reality::TestCase
   def test_template_set_container
     assert_equal 0, TestTemplateSetContainer.template_sets.size
     assert_equal false, TestTemplateSetContainer.template_set_by_name?(:foo)
-    assert_raise_message('Unable to locate template_set foo') { TestTemplateSetContainer.template_set_by_name(:foo) }
+    assert_generator_error('Unable to locate template_set foo') { TestTemplateSetContainer.template_set_by_name(:foo) }
 
-    assert_raise_message("TemplateSet 'iris_entity' defined requirement on template set 'iris_shared' that does not exist.") {
+    assert_generator_error("TemplateSet 'iris_entity' defined requirement on template set 'iris_shared' that does not exist.") do
       Reality::Generators::TemplateSet.new(TestTemplateSetContainer,
                                            :iris_entity,
                                            :required_template_sets => [:iris_shared])
-    }
+    end
 
     template_set1 = TestTemplateSetContainer.template_set(:foo)
 

data/test/helper.rb

@@ -6,26 +6,24 @@ require 'reality/generators'
 
 class Reality::TestCase < Minitest::Test
   include Test::Unit::Assertions
-
-  module TestGenerator
-    class << self
-      include Reality::Generators::Generator
-    end
-  end
+  include Reality::Logging::Assertions
 
   module TestTemplateSetContainer
     class << self
       include Reality::Generators::TemplateSetContainer
 
-      def new_template_set(name, options, &block)
-        Reality::Generators::TemplateSet.new(self, name, options, &block)
+      def derive_default_helpers(options)
+        helpers
       end
 
-      def new_generator
-        TestGenerator
+      attr_writer :helpers
+
+      def helpers
+        @helpers ||= []
       end
 
       def reset
+        helpers.clear
         template_set_map.clear
         target_manager.reset_targets
       end
@@ -52,4 +50,10 @@ class Reality::TestCase < Minitest::Test
     end
     @temp_dir
   end
+
+  def assert_generator_error(expected_message, &block)
+    assert_logging_error(Reality::Generators, expected_message) do
+      yield block
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reality-generators
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Peter Donald
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-07 00:00:00.000000000 Z
+date: 2016-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reality-core
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: reality-naming
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: reality-orderedhash
   requirement: !ruby/object:Gem::Requirement
@@ -102,17 +102,22 @@ files:
 - lib/reality/generators/generator.rb
 - lib/reality/generators/render_context.rb
 - lib/reality/generators/ruby_template.rb
+- lib/reality/generators/standard_artifact_dsl.rb
+- lib/reality/generators/standard_template_set.rb
 - lib/reality/generators/target_manager.rb
 - lib/reality/generators/template.rb
 - lib/reality/generators/template_set.rb
 - lib/reality/generators/template_set_container.rb
 - reality-generators.gemspec
-- test/generators/templates/mytemplate.java.erb
-- test/generators/templates/rubytemplate.rb
+- test/generators/jpa/model.rb
+- test/generators/jpa/templates/mytemplate.java.erb
+- test/generators/jpa/templates/rubytemplate.java.rb
 - test/generators/test_erb_template.rb
 - test/generators/test_generator.rb
 - test/generators/test_render_context.rb
 - test/generators/test_ruby_template.rb
+- test/generators/test_standard_artifact_dsl.rb
+- test/generators/test_standard_template_set.rb
 - test/generators/test_target_manager.rb
 - test/generators/test_template.rb
 - test/generators/test_template_set.rb