rgen 0.4.3 → 0.4.4

data/lib/rgen/name_helper.rb.bak

@@ -1,37 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-module RGen
-
-module NameHelper
-
-	def normalize(name)
-		name.gsub(/\W/,'_')
-	end
-	
-	def className(object)
-		object.class.name =~ /::(\w+)$/; $1
-	end
-	
-	def firstToUpper(str)
-		str[0..0].upcase + ( str[1..-1] || "" )
-	end
-	
-	def firstToLower(str)
-		str[0..0].downcase + ( str[1..-1] || "" )
-	end
-	
-	def saneClassName(str)
-		firstToUpper(normalize(str)).sub(/^Class$/, 'Clazz')
-	end
-	
-	def saneMethodName(str)
-		firstToLower(normalize(str)).sub(/^class$/, 'clazz')
-	end	
-	
-  def camelize(str)
-    str.split(/[\W_]/).collect{|s| firstToUpper(s.downcase)}.join
-  end
-end
-
-end

data/lib/rgen/template_language.rb.bak

@@ -1,289 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-require 'rgen/template_language/directory_template_container'
-require 'rgen/template_language/template_container'
-
-module RGen
-
-# The RGen template language has been designed to build complex generators.
-# It is very similar to the EXPAND language of the Java based
-# OpenArchitectureWare framework.
-# 
-# =Templates
-# 
-# The basic idea is to allow "templates" not only being template files
-# but smaller parts. Those parts can be expanded from other parts very 
-# much like Ruby methods are called from other methods.
-# Thus the term "template" refers to such a part within a "template file".
-# 
-# Template files used by the RGen template language should have a 
-# filename with the postfix ".tpl". Those files can reside within (nested)
-# template file directories.
-# 
-# As an example a template directory could look like the following:
-# 
-#   templates/root.tpl
-#   templates/dbaccess/dbaccess.tpl
-#   templates/dbaccess/schema.tpl
-#   templates/headers/generic_headers.tpl
-#   templates/headers/specific/component.tpl
-# 
-# A template is always called for a <i>context object</i>. The context object
-# serves as the receiver of methods called within the template. Details are given
-# below.
-# 
-# 
-# =Defining Templates
-# 
-# One or more templates can be defined in a template file using the +define+
-# keyword as in the following example:
-# 
-#   <% define 'GenerateDBAdapter', :for => DBDescription do |dbtype| %>
-#     Content to be generated; use ERB syntax here
-#   <% end %>
-#   
-# The template definition takes three kinds of parameters:
-# 1. The name of the template within the template file as a String or Symbol
-# 2. An optional class object describing the class of context objects for which
-#    this template is valid.
-# 3. An arbitrary number of template parameters
-# See RGen::TemplateLanguage::TemplateContainer for details about the syntax of +define+.
-# 
-# Within a template, regular ERB syntax can be used. This is
-# * <code><%</code> and <code>%></code> are used to embed Ruby code
-# * <code><%=</code> and <code>%></code> are used to embed Ruby expressions with
-#   the expression result being written to the template output
-# * <code><%#</code> and <code>%></code> are used for comments
-# All content not within these tags is written to the template output verbatim.
-# See below for details about output files and output formatting.
-# 
-# All methods which are called from within the template are sent to the context
-# object.
-#
-# Experience shows that one easily forgets the +do+ at the end of the first 
-# line of a template definition. This will result in an ERB parse error.
-# 
-# 
-# =Expanding Templates
-# 
-# Templates are normally expanded from within other templates. The only
-# exception is the root template, which is expanded from the surrounding code.
-# 
-# Template names can be specified in the following ways:
-# * Non qualified name: use the template with the given name in the current template file
-# * Relative qualified name: use the template within the template file specified by the relative path
-# * Absolute qualified name: use the template within the template file specified by the absolute path
-# 
-# The +expand+ keyword is used to expand templates. 
-# 
-# Here are some examples:
-# 
-#   <% expand 'GenerateDBAdapter', dbtype, :for => dbDesc %>
-# 
-# <i>Non qualified</i>. Must be called within the file where 'GenerateDBAdapter' is defined.
-# There is one template parameter passed in via variable +dbtype+.
-# The context object is provided in variable +dbDesc+.
-#  
-#   <% expand 'dbaccess::ExampleSQL' %>
-# 
-# <i>Qualified with filename</i>. Must be called from a file in the same directory as 'dbaccess.tpl'
-# There are no parameters. The current context object will be used as the context 
-# object for this template expansion.
-# 
-#   <% expand '../headers/generic_headers::CHeader', :foreach => modules %>
-# 
-# <i>Relatively qualified</i>. Must be called from a location from which the file
-# 'generic_headers.tpl' is accessible via the relative path '../headers'.
-# The template is expanded for each module in +modules+ (which has to be an Array).
-# Each element of +modules+ will be the context object in turn.
-# 
-#   <% expand '/headers/generic_headers::CHeader', :foreach => modules %>
-# 
-# Absolutely qualified: The same behaviour as before but with an absolute path from
-# the template directory root (which in this example is 'templates', see above)
-# 
-# Sometimes it is neccessary to generate some text (e.g. a ',') in between the single
-# template expansion results from a <code>:foreach</code> expansion. This can be achieved by
-# using the <code>:separator</code> keyword:
-# 
-#   <% expand 'ColumnName', :foreach => column, :separator => ', ' %>
-#   
-# Note that the separator may also contain newline characters (\n). See below for
-# details about formatting.
-# 
-# 
-# =Formatting
-# 
-# For many generator tools a formatting postprocess (e.g. using a pretty printer) is 
-# required in order to make the output readable. However, depending on the kind of
-# generated output, such a tool might not be available.
-# 
-# The RGen template language has been design for generators which do not need a
-# postprocessing step. The basic idea is to eliminate all whitespace at the beginning
-# of template lines (the indentation that makes the _template_ readable) and output
-# newlines only after at least on character has been generated in the corresponding
-# line. This way there are no empty lines in the output and each line will start with
-# a non-whitspace character.
-# 
-# Starting from this point one can add indentation and newlines as required by using
-# explicit formatting commands:
-# * <code><%nl%></code> (newline) starts a new line
-# * <code><%iinc%></code> (indentation increment) increases the current indentation
-# * <code><%idec%></code> (indentation decrement) decreases the current indentation
-# * <code><%nonl%></code> (no newline) ignore next newline
-# * <code><%nows%></code> (no whitespace) ignore next whitespace
-# 
-# Indentation takes place for every new line in the output unless it is 0.
-# The initial indentation can be specified with a root +expand+ command by using
-# the <code>:indent</code> keyword.
-# 
-# Here is an example:
-# 
-#   expand 'GenerateDBAdapter', dbtype, :for => dbDesc, :indent => 1
-#   
-# Initial indentation defaults to 0. Normally <code><%iinc%></code> and 
-# <code><%idec%></code> are used to change the indentation.
-# The current indentation is kept for expansion of subtemplates.
-# 
-# Note that commands to ignore whitespace and newlines are still useful if output 
-# generated from multiple template lines should show up in one single output line.
-# 
-# Here is an example of a template generating a C program:
-# 
-#   #include <stdio.h>
-#   <%nl%>
-#   int main() {<%iinc%>
-#     printf("Hello World\n");
-#     return 0;<%idec>
-#   }
-#   
-# The result is:
-# 
-#   #include <stdio.h>
-#   
-#   int main() {
-#      printf("Hello World\n");
-#      return 0;
-#   }
-# 
-# Note that without the explicit formatting commands, the output generated from the 
-# example above would not have any empty lines or whitespace in the beginning of lines.
-# This may seem like unneccessary extra work for the example above which could also
-# have been generated by passing the template to the output verbatimly.
-# However in most cases templates will contain more template specific indentation and
-# newlines which should be eliminated than formatting that should be visible in the 
-# output.
-# 
-# Here is a more realistic example for generating C function prototypes:
-# 
-#   <% define 'Prototype', :for => CFunction do %>
-#     <%= getType.name %> <%= name %>(<%nows%>
-#       <% expand 'Signature', :foreach => argument, :separator => ', ' %>);
-#   <% end %>
-#   
-#   <% define 'Signature', :for => CFunctionArgument do %>
-#     <%= getType.name %> <%= name%><%nows%>
-#   <% end %>
-#   
-# The result could look something like:
-# 
-#   void somefunc(int a, float b, int c);
-#   int otherfunc(short x);
-# 
-# In this example a separator is used to join the single arguments of the C functions.
-# Note that the template generating the argument type and name needs to contain
-# a <code><%nows%></code> if the result should consist of a single line.
-# 
-# Here is one more example for generating C array initializations:
-# 
-#   <% define 'Array', :for => CArray do %>
-#     <%= getType.name %> <%= name %>[<%= size %>] = {<%iinc%>
-#       <% expand 'InitValue', :foreach => initvalue, :separator => ",\n" %><%nl%><%idec%>
-#     };
-#   <% end %>
-#   
-#   <% define 'InitValue', :for => PrimitiveInitValue do %>
-#     <%= value %><%nows%>
-#   <% end %>
-# 
-# The result could look something like:
-# 
-#   int myArray[3] = {
-#      1,
-#      2,
-#      3
-#   };
-# 
-# Note that in this example, the separator contains a newline. The current increment
-# will be applied to each single expansion result since it starts in a new line.
-# 
-# 
-# =Output Files
-# 
-# Normally the generated content is to be written into one or more output files.
-# The RGen template language facilitates this by means of the +file+ keyword.
-# 
-# When the +file+ keyword is used to define a block, all output generated
-# from template code within this block will be written to the specified file.
-# This includes output generated from template expansions.
-# Thus all output from templates expanded within this block is written to
-# the same file as long as those templates do not use the +file+ keyword to 
-# define a new file context.
-# 
-# Here is an example:
-# 
-#   <% file 'dbadapter/'+adapter.name+'.c' do %>
-#     all content within this block will be written to the specified file
-#   <% end %>
-# 
-# Note that the filename itself can be calculated dynamically by an arbitrary
-# Ruby expression.
-# 
-# The absolute position where the output file is created depends on the output
-# root directory passed to DirectoryTemplateContainer as described below.
-# 
-# =Setting up the Generator
-# 
-# Setting up the generator consists of 3 steps:
-# * Instantiate DirectoryTemplateContainer passing one or more metamodel(s) and the output 
-#   directory to the constructor.
-# * Load the templates into the template container
-# * Expand the root template to start generation
-# 
-# Here is an example:
-#
-#   module MyMM
-#     # metaclasses are defined here, e.g. using RGen::MetamodelBuilder
-#   end
-# 
-#   OUTPUT_DIR = File.dirname(__FILE__)+"/output"
-#   TEMPLATES_DIR = File.dirname(__FILE__)+"/templates"
-# 
-#   tc = RGen::TemplateLanguage::DirectoryTemplateContainer.new(MyMM, OUTPUT_DIR)
-#   tc.load(TEMPLATES_DIR)
-#   # testModel should hold an instance of the metamodel class expected by the root template
-#   # the following line starts generation
-#   tc.expand('root::Root', :for => testModel, :indent => 1)
-# 
-# The metamodel is the Ruby module which contains the metaclasses.
-# This information is required for the template container in order to resolve the
-# metamodel classes used within the template file. 
-# If several metamodels shall be used, an array of modules can be passed instead
-# of a single module.
-# 
-# The output path is prepended to the relative paths provided to the +file+ 
-# definitions in the template files.
-#
-# The template directory should contain template files as described above.
-#
-# Finally the generation process is started by calling +expand+ in the same way as it
-# is used from within templates.
-# 
-# Also see the unit tests for more examples.
-# 
-module TemplateLanguage
-
-end
-
-end

data/lib/rgen/template_language/directory_template_container.rb.bak

@@ -1,69 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-require 'rgen/template_language/template_container'
-require 'rgen/template_language/template_helper'
-
-module RGen
-  
-module TemplateLanguage
-    
-class DirectoryTemplateContainer
-  include TemplateHelper
-  
-  def initialize(metamodel=nil, output_path=nil, parent=nil)
-    @containers = {}
-    @parent = parent
-    @metamodel = metamodel
-    @output_path = output_path
-  end
-  
-  def load(dir)
-    #print "Loading templates in #{dir} ...\n"
-    Dir.foreach(dir) { |f|
-      qf = dir+"/"+f
-      if !File.directory?(qf) && f =~ /^(.*)\.tpl$/
-       (@containers[$1] = TemplateContainer.dup.new(@metamodel, @output_path, self,qf)).load
-      elsif File.directory?(qf) && f != "." && f != ".."
-       (@containers[f] = DirectoryTemplateContainer.new(@metamodel, @output_path, self)).load(qf)
-      end
-    }
-  end
-  
-  def expand(template, *all_args)
-    if template =~ /^\//
-      if @parent
-        # pass to parent
-        @parent.expand(template, *all_args)
-      else
-        # this is root
-        _expand(template, *all_args)
-      end
-    elsif template =~ /^\.\.\/(.*)/
-      if @parent
-        # pass to parent
-        @parent.expand($1, *all_args)
-      else
-        raise "No parent directory for root"
-      end
-    else
-      _expand(template, *all_args)
-    end
-  end
-  
-  private
-  
-  def _expand(template, *all_args)
-    if template =~ /^\/?([^:\/]+)(?:::|\/)([^:\/].*)/ 
-      raise "Template not found: #{$1}" unless @containers[$1]
-      @containers[$1].expand($2, *all_args)
-    else
-      raise "Invalid template name: #{template}"
-    end
-  end
-  
-end
-
-end
-    
-end

data/lib/rgen/template_language/output_handler.rb.bak

@@ -1,88 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-module RGen
-  
-module TemplateLanguage
-  
-  class OutputHandler
-    attr_writer :indent
-    
-    def initialize(indent=0, mode=:explicit)
-      self.mode = mode
-      @indent = indent
-      @state = :wait_for_nonws
-      @output = ""
-    end
-    
-    # ERB will call this method for every string s which is part of the
-    # template file in between %> and <%. If s contains a newline, it will
-    # call this method for every part of s which is terminated by a \n
-    # 
-    def concat(s)
-      return @output.concat(s) if s.is_a? OutputHandler
-      s = s.to_str.gsub(/^[\t ]*\r?\n/,'') if @ignoreNextNL
-      s = s.to_str.gsub(/^\s+/,'') if @ignoreNextWS
-      @ignoreNextNL = @ignoreNextWS = false if s =~ /\S/
-      if @mode == :direct
-        @output.concat(s)
-      elsif @mode == :explicit
-        while s.size > 0
-          if @state == :wait_for_nl
-            if s =~ /\A([^\r\n]*\r?\n)(.*)/m
-              rest = $2
-              @output.concat($1.gsub(/[\t ]+(?=\r|\n)/,''))
-              s = rest || ""
-              @state = :wait_for_nonws
-            else
-              @output.concat(s)
-              s = ""
-            end
-          elsif @state == :wait_for_nonws
-            if s =~ /\A\s*(\S+.*)/m
-              s = $1 || ""
-              if !@noIndentNextLine && !(@output.to_s.size > 0 && @output.to_s[-1] != "\n"[0])
-                @output.concat("   "*@indent)
-              else
-                @noIndentNextLine = false
-              end
-              @state = :wait_for_nl
-            else
-              s = ""
-            end
-          end
-        end
-      end
-    end
-    alias << concat
-    
-    def to_str
-      @output
-    end
-    alias to_s to_str
-    
-    def direct_concat(s)
-      @output.concat(s)
-    end
-    
-    def ignoreNextNL
-      @ignoreNextNL = true
-    end
-    
-    def ignoreNextWS
-      @ignoreNextWS = true
-    end
-    
-    def noIndentNextLine
-      @noIndentNextLine = true
-    end  
-      
-    def mode=(m)
-      raise StandardError.new("Unknown mode: #{m}") unless [:direct, :explicit].include?(m)
-      @mode = m
-    end
-  end
-  
-end
-  
-end