reality-generators 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7679877e032f2d62e74287861197e3bd37f398c6
-  data.tar.gz: 61eb90fff98fb5be6bf5d44294053130a59b1f37
+  metadata.gz: 03bc2bd3ea71e9f986d52a15efa87b778ab98758
+  data.tar.gz: e6e5fed040e98cd4584b7a8e9c389b09e7f20a96
 SHA512:
-  metadata.gz: 00a7962634b8441945b234bc75b4359143de2997656ada6452216d2df037b6609c6c3b0b1c76e491e676c653de1355d80d79ff9cdb585826c687b0e7633df3ec
-  data.tar.gz: 9d21cb01a34549f6293a40df37bae961dfd5cd5242df5f8996ca4ffb299a644421f2a6d28cd6a7aa9d5df576b693f2570fdd56d9184a35f46b8caec039fead09
+  metadata.gz: bd5609694d0b1cb8d3d9976e2c87de06d4d329deef9e8a0c1e9e458d3d54c1658ba21d387d049f76ab8a1034c9a4994137f2453937d19ce94f82b97cd1a0d9c7
+  data.tar.gz: f619d71a563afd4ec8332df622b95bb1fa4eff470fa66eb1dbf87e52079767e2edbb4843e7c16265f5b8cc7dd0fc51a5b9bf4401e0155ae241f9b420d0c0e931

data/.gitignore

@@ -6,3 +6,4 @@
 /patch.diff
 /pkg
 /rdoc
+/tmp

data/lib/reality/generators/buildr_integration.rb

@@ -0,0 +1,105 @@
+#
+# 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
+    module Generator
+      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
+          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
+              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
+
+            # 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
+
+            # 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
+
+            # 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
+
+            # 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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reality/generators/generator.rb

@@ -0,0 +1,122 @@
+#
+# 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
+
+    module Generator
+      class << self
+
+        # Return a list of templates loaded from specified template_set_keys
+        def load_templates_from_template_sets(template_set_container, template_set_keys)
+          template_map = {}
+          load_templates(template_set_container, template_map, template_set_keys, [])
+          template_map.values
+        end
+
+        # Actually perform the generation of files from specified templates.
+        # Files are generated to the specified target directory. Any files that
+        # are not generated by this process are deleted. The files generated are
+        # based on the specified templates.
+        # 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)
+          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)
+
+          templates.each do |template|
+            Generators.debug "Evaluating template: #{template.name}"
+            elements = targets[template.target]
+
+            elements.each do |element_pair|
+              element = element_pair[1]
+              if template.applicable?(element_pair[0]) && (filter.nil? || filter.call(template.target, element))
+                template.generate(directory, element, unprocessed_files)
+              end
+            end if elements
+          end
+
+          unprocessed_files.sort.reverse.each do |file|
+            if File.directory?(file)
+              if (Dir.entries(file) - %w(. ..)).empty?
+                Generators.debug "Removing #{file} as no longer generated"
+                FileUtils.rmdir file
+              end
+            else
+              Generators.debug "Removing #{file} as no longer generated"
+              FileUtils.rm_f file
+            end
+          end
+
+          Generators.info 'Generator completed'
+        end
+
+        private
+
+        def load_templates(template_set_container, 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)
+            processed_template_sets << template_set_key
+            load_templates(template_set_container, template_map, template_set.required_template_sets, processed_template_sets)
+            template_set.templates.each do |template|
+              template_map[template.name] = template
+            end
+          end
+        end
+
+        # Collect all generation targets. This is a map of type to an array of element pairs of that type.
+        # The element pair includes two elements, the "parent" standard element that is facet as per normal
+        # and the actual element that is used for generation. The first element is used when checking if
+        # element is applicable? to be generated while the second is basis of generation.
+        # i.e.
+        #
+        # {
+        #   :repository => [ [repository, repository] ],
+        #   :data_module => [ [module1, module1], [module2, module2]],
+        #   :entity => [[entity1, entity1], [entity2, entity2]],
+        #   :'keycloak.client' => [[repository, client]],
+        #   ...
+        # }
+        #
+        def collect_generation_targets(template_set_container, 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|
+            subelements = nil
+            subscope = nil
+            if target.standard?
+              subelements = element.send(target.access_method)
+            elsif element.facet_enabled?(target.facet_key)
+              subelements = element.send(target.facet_key).send(target.access_method)
+              subscope = element
+            end
+
+            next unless subelements
+            subelements = [subelements] unless subelements.is_a?(Array)
+
+            subelements.each do |subelement|
+              collect_generation_targets(template_set_container, target.qualified_key, subscope || subelement, subelement, targets)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reality/generators/template.rb

@@ -112,7 +112,7 @@ module Reality #nodoc
     class SingleFileOutputTemplate < Template
       attr_reader :output_filename_pattern
 
-      def initialize(template_set, facets, target, template_key, output_filename_pattern, helpers, options = {})
+      def initialize(template_set, facets, target, template_key, output_filename_pattern, helpers = [], options = {})
         super(template_set, facets, target, template_key, helpers, options)
         @output_filename_pattern = output_filename_pattern
       end

data/lib/reality/generators.rb

@@ -26,3 +26,6 @@ require 'reality/generators/ruby_template'
 require 'reality/generators/erb_template'
 require 'reality/generators/template_set'
 require 'reality/generators/template_set_container'
+require 'reality/generators/generator'
+
+require 'reality/generators/buildr_integration'

data/reality-generators.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name               = %q{reality-generators}
-  s.version            = '1.0.0'
+  s.version            = '1.1.0'
   s.platform           = Gem::Platform::RUBY
 
   s.authors            = ['Peter Donald']

data/test/generators/test_generator.rb

@@ -0,0 +1,280 @@
+require File.expand_path('../../helper', __FILE__)
+require 'date'
+
+class Reality::Generators::TestGenerator < 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 PersistenceUnit < Reality.base_element(:name => true, :container_key => :jpa_repository)
+  end
+
+  class JpaRepository < Reality.base_element(:container_key => :repository)
+
+    def unit(name, options = {}, &block)
+      unit_map[name.to_s] = PersistenceUnit.new(self, name, options, &block)
+    end
+
+    def units
+      unit_map.values
+    end
+
+    def unit_map
+      @unit_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
+
+    def facet_enabled?(facet)
+      facet == :jpa ? !!@jpa : false
+    end
+
+    def jpa
+      @jpa
+    end
+
+    def enable_jpa!
+      @jpa = JpaRepository.new(self)
+    end
+  end
+
+  def test_collect_generation_targets
+    repository = Repository.new(:MyRepo) do |r|
+      r.entity(:MyEntityA) do |e|
+        e.attribute(:MyAttr1)
+        e.attribute(:MyAttr2)
+      end
+
+      r.entity(:MyEntityB) do |e|
+        e.attribute(:MyAttr3)
+        e.attribute(:MyAttr4)
+      end
+    end
+
+    TestTemplateSetContainer.target_manager.target(:repository)
+    TestTemplateSetContainer.target_manager.target(:entity, :repository)
+    TestTemplateSetContainer.target_manager.target(:attribute, :entity)
+    TestTemplateSetContainer.target_manager.target(:unit, :repository, :facet_key => :jpa)
+
+    targets = {}
+    Reality::Generators::Generator.send(:collect_generation_targets, TestTemplateSetContainer, :repository, repository, repository, targets)
+
+    assert_equal true, targets.include?(:repository)
+    assert_equal true, targets.include?(:entity)
+    assert_equal true, targets.include?(:attribute)
+    assert_equal 3, targets.size
+
+    assert_equal 1, targets[:repository].size
+    assert_equal 2, targets[:entity].size
+    assert_equal 4, targets[:attribute].size
+
+    assert_equal :MyRepo, targets[:repository][0][0].name
+    assert_equal :MyRepo, targets[:repository][0][1].name
+    assert_equal 'MyRepo.MyEntityA', targets[:entity][0][0].qualified_name
+    assert_equal 'MyRepo.MyEntityA', targets[:entity][0][1].qualified_name
+    assert_equal 'MyRepo.MyEntityB', targets[:entity][1][0].qualified_name
+    assert_equal 'MyRepo.MyEntityB', targets[:entity][1][1].qualified_name
+    assert_equal 'MyRepo.MyEntityA.MyAttr1', targets[:attribute][0][0].qualified_name
+    assert_equal 'MyRepo.MyEntityA.MyAttr1', targets[:attribute][0][1].qualified_name
+    assert_equal 'MyRepo.MyEntityA.MyAttr2', targets[:attribute][1][0].qualified_name
+    assert_equal 'MyRepo.MyEntityA.MyAttr2', targets[:attribute][1][1].qualified_name
+    assert_equal 'MyRepo.MyEntityB.MyAttr3', targets[:attribute][2][0].qualified_name
+    assert_equal 'MyRepo.MyEntityB.MyAttr3', targets[:attribute][2][1].qualified_name
+    assert_equal 'MyRepo.MyEntityB.MyAttr4', targets[:attribute][3][0].qualified_name
+    assert_equal 'MyRepo.MyEntityB.MyAttr4', targets[:attribute][3][1].qualified_name
+
+    repository.enable_jpa!
+
+    targets = {}
+    Reality::Generators::Generator.send(:collect_generation_targets, TestTemplateSetContainer, :repository, repository, repository, targets)
+
+    # No units have been defined so no extra targets
+    assert_equal 3, targets.size
+
+    repository.jpa.unit(:MyUnit1)
+    repository.jpa.unit(:MyUnit2)
+
+    targets = {}
+    Reality::Generators::Generator.send(:collect_generation_targets, TestTemplateSetContainer, :repository, repository, repository, targets)
+
+    assert_equal true, targets.include?(:repository)
+    assert_equal true, targets.include?(:entity)
+    assert_equal true, targets.include?(:attribute)
+    assert_equal true, targets.include?(:'jpa.unit')
+    assert_equal 4, targets.size
+
+    assert_equal 1, targets[:repository].size
+    assert_equal 2, targets[:entity].size
+    assert_equal 4, targets[:attribute].size
+    assert_equal 2, targets[:'jpa.unit'].size
+
+    assert_equal :MyRepo, targets[:'jpa.unit'][0][0].name
+    assert_equal :MyUnit1, targets[:'jpa.unit'][0][1].name
+    assert_equal :MyRepo, targets[:'jpa.unit'][1][0].name
+    assert_equal :MyUnit2, targets[:'jpa.unit'][1][1].name
+  end
+
+  class RepositoryTemplate < Reality::Generators::SingleFileOutputTemplate
+    def render_to_string(context_binding)
+      eval('"Repository: #{repository.name}"', context_binding)
+    end
+  end
+
+  class EntityTemplate < Reality::Generators::SingleFileOutputTemplate
+    def render_to_string(context_binding)
+      eval('"Entity: #{entity.name}"', context_binding)
+    end
+  end
+
+  class AttributeTemplate < Reality::Generators::SingleFileOutputTemplate
+    def render_to_string(context_binding)
+      eval('"Attribute: #{attribute.name}"', context_binding)
+    end
+  end
+
+  class UnitTemplate < Reality::Generators::SingleFileOutputTemplate
+    def render_to_string(context_binding)
+      eval('"Unit: #{unit.name}"', context_binding)
+    end
+  end
+
+  def test_generate
+    repository = Repository.new(:MyRepo) do |r|
+      r.entity(:MyEntityA) do |e|
+        e.attribute(:MyAttr1)
+        e.attribute(:MyAttr2)
+      end
+
+      r.entity(:MyEntityB) do |e|
+        e.attribute(:MyAttr3)
+        e.attribute(:MyAttr4)
+      end
+    end
+
+    TestTemplateSetContainer.target_manager.target(:repository)
+    TestTemplateSetContainer.target_manager.target(:entity, :repository)
+    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')
+
+      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', [], {})
+    end
+
+    target_directory = "#{temp_dir}/generated/erb_template"
+
+    FileUtils.mkdir_p "#{target_directory}/some/dir/to/delete"
+    FileUtils.mkdir_p "#{target_directory}/main/java"
+    FileUtils.touch "#{target_directory}/main/java/Touched.java"
+    repo_file = "#{target_directory}/main/java/MyRepo.java"
+    File.open(repo_file, 'wb') do |f|
+      f.write 'Repository: MyRepo'
+    end
+    File.utime(File.atime(repo_file), DateTime.new(2001, 2, 3).to_time, repo_file)
+    original_mtime = File.mtime(repo_file)
+
+    filter = Proc.new { |artifact_type, artifact| artifact_type != :attribute || %w(MyAttr1 MyAttr2).include?(artifact.name.to_s) }
+    Reality::Generators::Generator.
+      generate(TestTemplateSetContainer, :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")
+    assert_equal true, File.directory?("#{target_directory}/main/java")
+    assert_equal true, File.exist?(repo_file)
+    assert_equal 'Repository: MyRepo', IO.read(repo_file)
+
+    # Ensure the file is not updated if contents identical
+    assert_equal original_mtime, File.mtime(repo_file)
+
+    # The guard says no for next element
+    assert_equal false, File.exist?("#{target_directory}/main/java/MyRepo/MyEntityA.java")
+
+    assert_equal true, File.exist?("#{target_directory}/main/java/MyRepo/MyEntityB.java")
+    assert_equal 'Entity: MyEntityB', IO.read("#{target_directory}/main/java/MyRepo/MyEntityB.java")
+
+    assert_equal true, File.exist?("#{target_directory}/main/java/MyRepo/MyEntityA/MyAttr1.java")
+    assert_equal 'Attribute: MyAttr1', IO.read("#{target_directory}/main/java/MyRepo/MyEntityA/MyAttr1.java")
+
+    assert_equal true, File.exist?("#{target_directory}/main/java/MyRepo/MyEntityA/MyAttr2.java")
+    assert_equal 'Attribute: MyAttr2', IO.read("#{target_directory}/main/java/MyRepo/MyEntityA/MyAttr2.java")
+
+    # The filters says no
+    assert_equal false, File.exist?("#{target_directory}/main/java/MyRepo/MyEntityB/MyAttr3.java")
+    assert_equal false, File.exist?("#{target_directory}/main/java/MyRepo/MyEntityB/MyAttr4.java")
+  end
+
+  def test_load_templates_from_template_sets
+
+    TestTemplateSetContainer.target_manager.target(:repository)
+    TestTemplateSetContainer.target_manager.target(:entity, :repository)
+    TestTemplateSetContainer.target_manager.target(:attribute, :entity)
+    TestTemplateSetContainer.target_manager.target(:unit, :repository, :facet_key => :jpa)
+
+    TestTemplateSetContainer.template_set(:template_set_1) do |template_set|
+      RepositoryTemplate.new(template_set, [], :repository, 'repository1.java', 'main/java/#{repository.name}1.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', [], {})
+    end
+
+    TestTemplateSetContainer.template_set(:template_set_2) do |template_set|
+      RepositoryTemplate.new(template_set, [], :repository, 'repository2.java', 'main/java/#{repository.name}2.java')
+    end
+
+    TestTemplateSetContainer.template_set(:template_set_3) do |template_set|
+      RepositoryTemplate.new(template_set, [], :repository, 'repository3.java', 'main/java/#{repository.name}3.java')
+    end
+
+    TestTemplateSetContainer.template_set(:template_set_4) do |template_set|
+      RepositoryTemplate.new(template_set, [], :repository, 'repository4.java', 'main/java/#{repository.name}3.java')
+
+      AttributeTemplate.new(template_set, [], :attribute, 'attribute4.java', 'main/java/#{attribute.qualified_name.gsub(".","/")}4.java')
+    end
+
+    template_set_keys = [:template_set_1, :template_set_4]
+    templates = Reality::Generators::Generator.
+      load_templates_from_template_sets(TestTemplateSetContainer, 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),
+                 templates.collect{|t| t.name}.sort
+
+  end
+end

data/test/helper.rb

@@ -37,7 +37,7 @@ class Reality::TestCase < Minitest::Test
   def temp_dir
     if @temp_dir.nil?
       base_temp_dir = ENV['TEST_TMP_DIR'] || File.expand_path("#{File.dirname(__FILE__)}/../tmp")
-      @temp_dir = "#{base_temp_dir}/generators-#{Time.now.to_i}"
+      @temp_dir = "#{base_temp_dir}/tests/generators-#{Time.now.to_i}"
       FileUtils.mkdir_p @temp_dir
     end
     @temp_dir

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reality-generators
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Peter Donald
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-04 00:00:00.000000000 Z
+date: 2016-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reality-core
@@ -96,8 +96,10 @@ files:
 - README.md
 - Rakefile
 - lib/reality/generators.rb
+- lib/reality/generators/buildr_integration.rb
 - lib/reality/generators/core.rb
 - lib/reality/generators/erb_template.rb
+- lib/reality/generators/generator.rb
 - lib/reality/generators/render_context.rb
 - lib/reality/generators/ruby_template.rb
 - lib/reality/generators/target_manager.rb
@@ -108,6 +110,7 @@ files:
 - test/generators/templates/mytemplate.java.erb
 - test/generators/templates/rubytemplate.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_target_manager.rb