reality-generators 1.0.0

data/lib/reality/generators/template.rb

@@ -0,0 +1,152 @@
+#
+# 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
+
+    # Error raised when template unable to generate
+    class GeneratorError < StandardError
+      attr_reader :cause
+
+      def initialize(message, cause = nil)
+        super(message)
+        @cause = cause
+      end
+    end
+
+    # Base class for all templates
+    class Template < Reality::BaseElement
+      attr_reader :template_set
+      attr_reader :template_key
+      attr_reader :guard
+      attr_reader :helpers
+      attr_reader :target
+      attr_reader :facets
+      attr_reader :extra_data
+
+      def initialize(template_set, facets, target, template_key, helpers, options = {})
+        Generators.error("Unexpected facets: #{facets.inspect}") unless facets.is_a?(Array) && facets.all? { |a| a.is_a?(Symbol) }
+        Generators.error("Unknown target '#{target}' for template '#{template_key}'. Valid targets include: #{template_set.container.target_manager.target_keys.join(', ')}") unless template_set.container.target_manager.is_target_valid?(target)
+        @template_set = template_set
+        @facets = facets
+        @target = target
+        @template_key = template_key
+        @helpers = helpers
+        @guard = options[:guard]
+        @name = options[:name] if options[:name]
+        @extra_data = options[:extra_data] || {}
+        template_set.send(:register_template, self)
+      end
+
+      def to_s
+        name
+      end
+
+      def applicable?(faceted_object)
+        return true if self.facets.empty?
+        return false unless faceted_object.respond_to?(:facet_enabled?)
+        self.facets.all? { |facet_key| faceted_object.facet_enabled?(facet_key) }
+      end
+
+      def output_path
+        Generators.error('output_path unimplemented')
+      end
+
+      def generate(target_basedir, element, unprocessed_files)
+        Generators.debug("Generating #{self.name} for #{self.target} #{name_for_element(element)}")
+        return nil unless guard_allows?(element)
+
+        generate!(target_basedir, element, unprocessed_files)
+      end
+
+      def name
+        @name ||= "#{self.template_set.name}:#{self.template_key.gsub(/.*\/templates\/(.*)\.#{template_extension}$/, '\1')}"
+      end
+
+      protected
+
+      def guard_allows?(element)
+        return true if self.guard.nil?
+        render_context = create_context(element)
+        context_binding = render_context.context_binding
+        eval(self.guard, context_binding, "#{self.template_key}#Guard")
+      end
+
+      def template_extension
+        ''
+      end
+
+      def generate!(target_basedir, element, unprocessed_files)
+        Generators.error('generate not implemented')
+      end
+
+      def name_for_element(element)
+        element.respond_to?(:qualified_name) ? element.qualified_name : element.name
+      end
+
+      def create_context(value)
+        context = RenderContext.new
+        context.set_local_variable(self.target.to_s.gsub(/^.*\./, ''), value)
+        self.extra_data.each_pair do |k, v|
+          context.set_local_variable(k, v)
+        end
+        self.helpers.each do |helper|
+          context.add_helper(helper)
+        end
+        context
+      end
+    end
+
+    # Base class for templates that generate a single file
+    class SingleFileOutputTemplate < Template
+      attr_reader :output_filename_pattern
+
+      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
+
+      def output_path
+        output_filename_pattern
+      end
+
+      protected
+
+      def generate!(target_basedir, element, unprocessed_files)
+        object_name = name_for_element(element)
+        render_context = create_context(element)
+        context_binding = render_context.context_binding
+        begin
+          output_filename = eval("\"#{self.output_filename_pattern}\"", context_binding, "#{self.template_key}#Filename")
+          output_filename = File.join(target_basedir, output_filename)
+          unprocessed_files.delete(output_filename)
+          result = self.render_to_string(context_binding)
+          FileUtils.mkdir_p File.dirname(output_filename) unless File.directory?(File.dirname(output_filename))
+          if File.exist?(output_filename) && IO.read(output_filename) == result
+            Generators.debug "Skipped generation of #{self.name} for #{self.target} #{object_name} to #{output_filename} due to no changes"
+          else
+            File.open(output_filename, 'w') { |f| f.write(result) }
+            Generators.debug "Generated #{self.name} for #{self.target} #{object_name} to #{output_filename}"
+          end
+        rescue => e
+          raise GeneratorError.new("Error generating #{self.name} for #{self.target} #{object_name} due to '#{e}'", e)
+        end
+      end
+
+      def render_to_string(context_binding)
+        Generators.error('render_to_string not implemented')
+      end
+    end
+  end
+end

data/lib/reality/generators/template_set.rb

@@ -0,0 +1,64 @@
+#
+# 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 collection of templates
+    class TemplateSet < Reality::BaseElement
+      attr_reader :name
+      attr_reader :container
+      attr_accessor :required_template_sets
+      attr_accessor :description
+
+      def initialize(container, name, options = {}, &block)
+        @container = container
+        @name = name
+        @required_template_sets = []
+        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."
+          end
+        end
+        container.send(:register_template_set, self)
+      end
+
+      def templates
+        template_map.values
+      end
+
+      def template_by_name?(name)
+        !!template_map[name.to_s]
+      end
+
+      def template_by_name(name)
+        template = template_map[name.to_s]
+        Generators.error("Unable to locate template #{name}") unless template
+        template
+      end
+
+      private
+
+      def register_template(template)
+        Generators.error("Template already exists with specified name #{template.name}") if template_map[template.name]
+        template_map[template.name] = template
+      end
+
+      def template_map
+        @templates ||= Reality::OrderedHash.new
+      end
+    end
+  end
+end

data/lib/reality/generators/template_set_container.rb

@@ -0,0 +1,65 @@
+#
+# 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 TemplateSetContainer
+      def template_sets
+        template_set_map.values
+      end
+
+      def template_set(name, options = {}, &block)
+        if name.is_a?(Hash) && name.size == 1
+          req = name.values[0]
+          options = options.dup
+          options[:required_template_sets] = req.is_a?(Array) ? req : [req]
+          name = name.keys[0]
+        end
+        new_template_set(name.to_s, options, &block)
+      end
+
+      def template_set_by_name?(name)
+        !!template_set_map[name.to_s]
+      end
+
+      def template_set_by_name(name)
+        template_set = template_set_map[name.to_s]
+        Generators.error("Unable to locate template_set #{name}") unless template_set
+        template_set
+      end
+
+      def target_manager
+        @target_manager ||= Reality::Generators::TargetManager.new(self)
+      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]
+        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')
+      end
+
+      private
+
+      def template_set_map
+        @template_sets ||= Reality::OrderedHash.new
+      end
+    end
+  end
+end

data/lib/reality/generators.rb

@@ -0,0 +1,28 @@
+#
+# 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.
+#
+
+require 'erb'
+
+require 'reality/core'
+require 'reality/naming'
+require 'reality/orderedhash'
+
+require 'reality/generators/core'
+require 'reality/generators/render_context'
+require 'reality/generators/target_manager'
+require 'reality/generators/template'
+require 'reality/generators/ruby_template'
+require 'reality/generators/erb_template'
+require 'reality/generators/template_set'
+require 'reality/generators/template_set_container'

data/reality-generators.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name               = %q{reality-generators}
+  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-generators}
+  s.summary            = %q{A basic toolkit for abstracting the generation of files from model objects.}
+  s.description        = %q{A basic toolkit for abstracting the generation of files from 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-generators)
+
+  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/generators/templates/mytemplate.java.erb

@@ -0,0 +1,6 @@
+/* DO NOT EDIT: File is auto-generated */
+
+@javax.annotation.Generated( "reality-generators" )
+public class <%= component.name %>
+{
+}

data/test/generators/templates/rubytemplate.rb

@@ -0,0 +1,3 @@
+def generate(model)
+  "Here is a #{model.name}"
+end

data/test/generators/test_erb_template.rb

@@ -0,0 +1,53 @@
+require File.expand_path('../../helper', __FILE__)
+
+class Reality::Generators::TestErbTemplate < Reality::TestCase
+
+  class SimpleModel
+    def name
+      'SimpleModel'
+    end
+
+    def facet_enabled?(facet)
+      true
+    end
+  end
+
+  def test_erb_template
+    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')
+    TestTemplateSetContainer.target_manager.target(:component)
+
+    template1 = Reality::Generators::ErbTemplate.new(template_set, [], :component, template_filename, output_filename_pattern, [], {})
+
+    assert_equal output_filename_pattern, template1.output_filename_pattern
+    assert_equal output_filename_pattern, template1.output_path
+    assert_equal template_set, template1.template_set
+    assert_equal [], template1.facets
+    assert_equal :component, template1.target
+    assert_equal [], template1.helpers
+    assert_equal template_filename, template1.template_key
+    assert_equal nil, template1.guard
+    assert_equal({}, template1.extra_data)
+    assert_equal 'foo:mytemplate.java', template1.name
+
+    target_basedir = "#{temp_dir}/generated/erb_template"
+    target_filename = "#{target_basedir}/main/java/SimpleModel.java"
+    other_filename = "#{target_basedir}/main/java/Other.java"
+    unprocessed_files = %W(#{target_filename} #{other_filename})
+    assert_equal false, File.exist?(target_filename)
+    template1.generate(target_basedir, SimpleModel.new, unprocessed_files)
+    assert_equal true, File.exist?(target_filename)
+    assert_equal 1, unprocessed_files.size
+
+    assert_equal <<JAVA, IO.read(target_filename)
+/* DO NOT EDIT: File is auto-generated */
+
+@javax.annotation.Generated( "reality-generators" )
+public class SimpleModel
+{
+}
+JAVA
+  end
+end

data/test/generators/test_render_context.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../../helper', __FILE__)
+
+class Reality::Generators::TestRenderContext < Reality::TestCase
+
+  module MyHelper
+    def gen_x
+      'X'
+    end
+
+    def gen_y
+      'Y'
+    end
+  end
+
+  def test_basic_operation
+    render_context = Reality::Generators::RenderContext.new
+
+    assert_equal 'Missing', eval("gen_x rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Missing', eval("gen_y rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Missing', eval("a rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Missing', eval("b rescue 'Missing'", render_context.context_binding)
+
+    render_context.add_helper(MyHelper)
+
+    assert_equal 'X', eval("gen_x rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Y', eval("gen_y rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Missing', eval("a rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Missing', eval("b rescue 'Missing'", render_context.context_binding)
+
+    render_context.set_local_variable(:a, 'A')
+
+    assert_equal 'X', eval("gen_x rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Y', eval("gen_y rescue 'Missing'", render_context.context_binding)
+    assert_equal 'A', eval("a rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Missing', eval("b rescue 'Missing'", render_context.context_binding)
+
+    render_context.set_local_variable(:b, 'B')
+
+    assert_equal 'X', eval("gen_x rescue 'Missing'", render_context.context_binding)
+    assert_equal 'Y', eval("gen_y rescue 'Missing'", render_context.context_binding)
+    assert_equal 'A', eval("a rescue 'Missing'", render_context.context_binding)
+    assert_equal 'B', eval("b rescue 'Missing'", render_context.context_binding)
+  end
+end

data/test/generators/test_ruby_template.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../../helper', __FILE__)
+
+class Reality::Generators::TestRubyTemplate < Reality::TestCase
+
+  class SimpleModel
+    def name
+      'SimpleModel'
+    end
+
+    def facet_enabled?(facet)
+      true
+    end
+  end
+
+  def test_ruby_template
+    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')
+    TestTemplateSetContainer.target_manager.target(:component)
+
+    template1 = Reality::Generators::RubyTemplate.new(template_set, [], :component, template_filename, output_filename_pattern, [], {})
+
+    assert_equal output_filename_pattern, template1.output_filename_pattern
+    assert_equal output_filename_pattern, template1.output_path
+    assert_equal template_set, template1.template_set
+    assert_equal [], template1.facets
+    assert_equal :component, template1.target
+    assert_equal [], template1.helpers
+    assert_equal template_filename, template1.template_key
+    assert_equal nil, template1.guard
+    assert_equal({}, template1.extra_data)
+    assert_equal 'foo:rubytemplate', template1.name
+
+    target_basedir = "#{temp_dir}/generated/ruby_template"
+    target_filename = "#{target_basedir}/main/java/SimpleModel.java"
+    other_filename = "#{target_basedir}/main/java/Other.java"
+    unprocessed_files = %W(#{target_filename} #{other_filename})
+    assert_equal false, File.exist?(target_filename)
+    template1.generate(target_basedir, SimpleModel.new, unprocessed_files)
+    assert_equal true, File.exist?(target_filename)
+    assert_equal 1, unprocessed_files.size
+
+    assert_equal 'Here is a SimpleModel', IO.read(target_filename)
+  end
+end

data/test/generators/test_target_manager.rb

@@ -0,0 +1,89 @@
+require File.expand_path('../../helper', __FILE__)
+
+class Reality::Generators::TestTargetManager < Reality::TestCase
+
+  def test_target
+    target_manager = Reality::Generators::TargetManager.new(TestTemplateSetContainer)
+    target1 = Reality::Generators::Target.new(target_manager, :repository, nil, {})
+
+    assert_equal :repository, target1.qualified_key
+    assert_equal :repository, target1.key
+    assert_equal nil, target1.container_key
+    assert_equal 'repositories', target1.access_method
+    assert_equal nil, target1.facet_key
+    assert_equal true, target1.standard?
+
+    target2 = Reality::Generators::Target.new(target_manager, :data_module, :repository, {})
+
+    assert_equal :data_module, target2.qualified_key
+    assert_equal :data_module, target2.key
+    assert_equal :repository, target2.container_key
+    assert_equal 'data_modules', target2.access_method
+    assert_equal nil, target2.facet_key
+    assert_equal true, target2.standard?
+
+    target3 = Reality::Generators::Target.new(target_manager, :entrypoint, :repository, :facet_key => :gwt)
+
+    assert_equal :'gwt.entrypoint', target3.qualified_key
+    assert_equal :entrypoint, target3.key
+    assert_equal :repository, target3.container_key
+    assert_equal 'entrypoints', target3.access_method
+    assert_equal :gwt, target3.facet_key
+    assert_equal false, target3.standard?
+
+    target4 = Reality::Generators::Target.new(target_manager, :persistence_unit, :repository, :facet_key => :jpa, :access_method => 'standard_persistence_units')
+
+    assert_equal :'jpa.persistence_unit', target4.qualified_key
+    assert_equal :persistence_unit, target4.key
+    assert_equal :repository, target4.container_key
+    assert_equal 'standard_persistence_units', target4.access_method
+    assert_equal :jpa, target4.facet_key
+    assert_equal false, target4.standard?
+
+    target1 = Reality::Generators::Target.new(target_manager, :project, nil, :access_method => 'project_set')
+
+    assert_equal :project, target1.qualified_key
+    assert_equal :project, target1.key
+    assert_equal nil, target1.container_key
+    assert_equal 'project_set', target1.access_method
+    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_raise_message("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
+
+    target_manager = Reality::Generators::TargetManager.new(TestTemplateSetContainer)
+
+    assert_equal false, target_manager.is_target_valid?(:project)
+    assert_equal [], target_manager.target_keys
+    assert_equal false, target_manager.target_by_key?(:project)
+
+    target_manager.target(:project)
+
+    assert_equal true, target_manager.is_target_valid?(:project)
+    assert_equal [:project], target_manager.target_keys
+    assert_equal true, target_manager.target_by_key?(:project)
+    assert_equal 1, target_manager.targets.size
+    assert_equal :project, target_manager.targets[0].key
+
+    target_manager.target(:component, :project, :facet_key => :jsc, :access_method => 'comps')
+
+    assert_equal true, target_manager.is_target_valid?(:'jsc.component')
+    assert_equal true, target_manager.target_by_key?(:'jsc.component')
+    assert_equal 2, target_manager.targets.size
+    target = target_manager.target_by_key(:'jsc.component')
+    assert_equal :component, target.key
+    assert_equal :project, target.container_key
+    assert_equal :jsc, target.facet_key
+    assert_equal 'comps', target.access_method
+
+    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) }
+  end
+end