templator 0.1 → 0.2

data/CHANGES

@@ -0,0 +1,6 @@
+= 0.1.1 / 2012-02-03
+    * Fix bug when doing recursive calls to include_file action,
+      only the result of the last call was included in the generated file. 
+
+= 0.1 
+    * First release

data/Gemfile

@@ -8,4 +8,6 @@ end
 
 group :test do
   gem "rspec"
+  gem "fakefs"
+  gem "pry"
 end

data/Gemfile.lock

@@ -1,22 +1,32 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    coderay (1.0.8)
     diff-lcs (1.1.3)
-    rspec (2.7.0)
-      rspec-core (~> 2.7.0)
-      rspec-expectations (~> 2.7.0)
-      rspec-mocks (~> 2.7.0)
-    rspec-core (2.7.1)
-    rspec-expectations (2.7.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.7.0)
-    thor (0.14.6)
-    yard (0.7.3)
+    fakefs (0.4.2)
+    method_source (0.8.1)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.0)
+    rspec-expectations (2.12.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
+    slop (3.3.3)
+    thor (0.16.0)
+    yard (0.8.3)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  fakefs
+  pry
   rspec
   thor
   yard

data/README.md

@@ -99,56 +99,56 @@ and :parameter2 is gotten by invoking the corresponding methods, parameter1 et p
 
 The group method allows to define a subset of parameters.
 
-    group :my_group {
+    group :my_group do
         export :my_parameter => "my_value"
-    }
+    end
 
 Nested group is also possible:
 
-    group :top {
-        group :inner {
+    group :top do
+        group :inner do
             ...
-        }
-    }
+        end
+    end
 
 Value of parameters defined in other groups must be retrieved with 
 the fully qualified name of the parameter in dot notation.
 
-    group :foo_group {
+    group :foo_group do
         export :foo => "foo"
-    }
+    end
 
-    group :bar_group {
+    group :bar_group do
         export :bar => "bar"
-    }
+    end
 
-    group :foobar_group {
+    group :foobar_group do
         export :foobar => foo_group.foo + bar_group.bar
-    }
+    end
 
 A group can de defined multiple times. The resulting group is a merge of all
 definitions taking into account the order of the parsing:
 
     #file1
-    group :my_group {
+    group :my_group do
         export :parameter1 => 1
         export :parameter2 => 2
-    }
+    end
 
     #file2
-    group :my_group {
+    group :my_group do
         export :parameter1 => 0.99999
         export :parameter3 => 3
-    }
+    end
 
 Assuming that file1 and file2 are parsed in this order, the resulting group 
 is semantically equivalent to this one:
 
-    group :my_group {
+    group :my_group do
         export :parameter1 => 0.99999
         export :parameter2 => 2
         export :parameter3 => 3
-    }
+    end
 
  * __include_group__
 
@@ -158,21 +158,21 @@ It is conceptually equivalent to the well known Ruby include method.
 
 Consider the following example:
 
-    group :mixin {
+    group :mixin do
         export :mixme => "some value"
-    }
+    end
 
-    group :my_group {
+    group :my_group do
         include_group :mixin
         export :another_parameter => "another_value"
-    }
+    end
 
 Thus, the resulting group is equivalent to :
 
-    group :my_group {
+    group :my_group do
         export :mixme => "some value"
         export :another_parameter => "another_value"
-    }
+    end
 
 Template Actions
 ----------------
@@ -183,15 +183,15 @@ In addition to the features provided by ERB, the following extra methods can be
 
  * __param__
 
-This method allows to retrieve the value of a parameter. 
+This method allows to retrieve the value of parameters passed to Templator by the __-p__ swicth. 
 
 Here is a concrete example:
 
 File _parameters.txt_:
 
-    group :my_group {
-        export my_parameter => "my_value"
-    }
+    group :my_group do
+        export :my_parameter => "my_value"
+    end
     ...
 
 File _template.txt_:
@@ -229,7 +229,7 @@ Here is an example that dynamically generates the name of the template to
 include according to the value of a parameter:
 
     blah blah blah
-    <%= include_file "#{param :my_parameter}.txt"
+    <%= include_file "#{param :my_parameter}.txt" %>
 
 The path of the template to include is interpreted relatively from the path
 of the source template. 
@@ -255,23 +255,27 @@ file for three different hosts.
 
 File _hosts.txt_:
 
-    group :host_a {
+    group :common_parameters do
+        export :gateway => "192.168.121.254"
+    end
+
+    group :host_a do
         export :address => "192.168.121.1"
         export :netmask => "255.255.255.0"
-        export :gateway => "192.168.121.254"
-    }
+        include_group :common_parameters
+    end
 
-    group :host_b {
-        export :address => "192.168.122.1"
+    group :host_b do
+        export :address => "192.168.121.2"
         export :netmask => "255.255.255.0"
-        export :gateway => "192.168.122.254"
-    }
+        include_group :common_parameters
+    end
 
-    group :host_c {
-        export :address => "192.168.123.1"
+    group :host_c do
+        export :address => "192.168.121.3"
         export :netmask => "255.255.255.0"
-        export :gateway => "192.168.123.254"
-    }
+        include_group :common_parameters
+    end
 
 File _interfaces.txt_:
 

data/bin/templator

@@ -4,7 +4,9 @@ if RUBY_VERSION < "1.9"
   require "rubygems"
 end
 
-$LOAD_PATH << "../lib"
+lib_dir=File.expand_path(File.join(File.dirname(__FILE__), '../lib'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
 require "thor"
 require "templator/parameters"
 require "templator/actions"
@@ -36,7 +38,12 @@ class TemplatorCli < Thor
     @template = template
 
     if options.has_key?("parameter-files")
-      @parameters = Templator::Parameters.load_files *options["parameter-files"]
+      begin
+        @parameters = Templator::Parameters.load_files *options["parameter-files"]
+      rescue Exception => e
+        error e
+        exit 1
+      end
     end
 
     template template, output
@@ -94,43 +101,6 @@ class TemplatorCli < Thor
     def method_missing(method, *args)
       @parameters.get(method)
     end
-
-    # Check global consistency of provided options
-    def sanity_check
-
-      #mutually exclusive options
-      mandatory_and_mutually_exclusive "template-directory",  "template-file"
-      optional_and_mutually_exclusive "output-directory",    "output-file"
-
-      #dependent option
-      dependent "template-file", "output-file"
-      dependent "template-directory", "output-directory"
-    end
-
-    # Check that options hash has one and only one of two given keys
-    def mandatory_and_mutually_exclusive(key1, key2)
-      raise Thor::Error.new("One of --#{key1} or --#{key2} must be provided. Try again.") unless (options.has_key?(key1) ^ options.has_key?(key2))
-    end
-
-    # Check that options hash has zero or one of two given keys
-    def optional_and_mutually_exclusive(key1, key2)
-      raise Thor::Error.new("Only one of --#{key1} or --#{key2} must be provided. Try again.") unless (options.has_key(key1) || options.has_key?(key2)) || ! (options.has_key?(key1) && options.has_key?(key2))
-    end
-
-    # Check that options hash has child_key if it has parent_key.
-    def dependent(parent_key, child_key)
-      raise Thor::Error.new("--#{child_key} must be provided when using --#{parent_key}. Try again.") if  (options.has_key?(parent_key) && ! options.has_key?(child_key))
-    end
-
-    # Build a list of template files from provided options
-    def templates
-      options.has_key?("template-file") ? [options["template-file"]] : options["template-directory"]
-    end
-
-    # Build the output path based on the given option and the current template file.
-    def output_path(template_file)
-      options.has_key?("output-directory") ? File.join(options["output-directory"], template_file) : options["output-file"]
-    end
   end
 end
 

data/lib/templator/actions.rb

@@ -28,7 +28,7 @@ module Templator
         search_path.each do |dir|
           path = File.join(dir, filename)
           if File.exist?(path) 
-            content = ERB.new(::File.read(path), nil, '-', '@included_template').result(binding)
+            content = ERB.new(::File.read(path), nil, '-', 'included_template').result(binding)
             throw :file_found
           end
         end

data/lib/templator/parameter_dsl.rb

@@ -1,6 +1,7 @@
 module Templator
 
-  # Defines and interprets the methods of the Parameter DSL.
+  # Parse a the given files with respect to the Parameter DSL.
+  #
   # Supported DSL methods are :
   # * export(hash) : defines a list of parameters from the given hash
   # * group(name, block) : defines a group of parameter
@@ -23,32 +24,142 @@ module Templator
   #    include_group "group2.group3"
   #  end
   #
-  #
   # param5 value can retrieved with the following :
-  #  p = ParameterDsl.new.parse(code)
+  #  p = ParameterFileLoader.new.parse("path/to/parameter_file")
   #  p.group2.param5
   #
-  #
-  class ParameterDsl
+  class ParameterFileLoader
 
-    # Name of the implicit top level group
-    TOP_LEVEL_GROUP_NAME = "__top__"
+    # Parses the given files
+    # @param [String[]] files files to parse
+    # @return [Object] a dynamically built object 
+    #  whose methods allow to access values of parameters defined in given code.
+    def parse(*files)
+      files.each do |file|
+        begin
+          load file
+        rescue ::Exception => e
+          raise ParseError.new(e, file)
+        end
+      end
+      DslContext.top_level_group
+    end
 
-    def initialize
-      #initialize the top level group
-      @group_stack = []
-      @group_stack.push Group.new(TOP_LEVEL_GROUP_NAME)
+  end
+
+  # Error wrapper of all errors occuring during the parsing of a parameter file.
+  # This wrapper provides convenient methods to retrieve the origin of the error.
+  class ParseError < Exception
+    
+    attr_reader :file, :line
+
+    def initialize(original_exception, file)
+      @original_exception = original_exception
+      @file = file
+
+      process original_exception
     end
 
-    # Parses the given code
-    # @param [String] code code to parse
-    # @return [Object] a dynamically built object 
-    #  whose methods allow to access values of parameters defined in given code.
-    def parse(code)
-      instance_eval code
-      @group_stack.first
+
+    def message_to_s
+      @message.sub(/\A.*:\d+:\s*/, "")
+    end
+
+    def origin_to_s
+      "in file #{file}" + (@line ? " line #{@line}" : "")
+    end
+
+
+    def to_s
+      "ParseError #{origin_to_s}: #{message_to_s}"
+    end
+
+    private 
+
+    def process(exception)
+      @message = exception.message
+
+      case exception
+      when LoadError, ::SyntaxError
+        trace = nil
+      else
+        trace = exception.backtrace.drop_while {|line| line.match(/#{__FILE__}/)}.first
+      end
+
+      @line = find_line_number_in_trace trace if trace
+    end
+
+    def find_line_number_in_trace(trace)
+      line = nil
+      matcher = trace.match(/:(\d+):/)
+      line = matcher[1].to_i if matcher
+    end
+
+  end
+
+  # Base class to define a group.
+  # A Group instance is created whenever a group method is parsed from the DSL code.
+  # Methods are dynamically created inside the singleton of the instance to access nested parameters and groups.
+  class Group
+    attr_reader :name
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  # Context used by the DSL methods to retrieve and update
+  # the current group.
+  class DslContext
+    
+    # Retrieve the current group from the context
+    # @return [Group] the current group
+    def self.current_group
+      group_stack.last
+    end
+
+    # Retrieve the top level group from the context
+    # @return [Group] the top level group
+    def self.top_level_group
+      group_stack.first
+    end
+
+    # Enter a new group.
+    # This method shall be called by the DSL methods whenever 
+    # a new group is entered.
+    # @param [Group] group group entered.
+    def self.enter_group(group)
+      group_stack.push(group)
+    end
+
+    # Leave a group.
+    # This method shall be calles by the DSL methods whenever
+    # a group is left.
+    def self.leave_group
+      group_stack.pop
     end
 
+    private
+
+    # Retrieve the stack of groups.
+    # The stack is automatically created on the first call
+    # and the top level group is inserted as the first element
+    # of the stack.
+    # @return [Array<Group>] the stack of groups.
+    def self.group_stack
+      if (@group_stack.nil?)
+        @group_stack = []
+        @group_stack.push Group.new(DslMethods::TOP_LEVEL_GROUP_NAME)
+      end
+      @group_stack
+    end
+  end
+
+  # Module that defines the Parameter DSL methods.
+  module DslMethods
+
+    # Name of the implicit top level group
+    TOP_LEVEL_GROUP_NAME = "__top__"
+
     # Defines parameters providing a name and a value for each parameter.
     # @param [Hash]params hash of parameter name and value 
     def export(params)
@@ -80,21 +191,21 @@ module Templator
 
     private
 
-    # Gets the current group from the group stack
+    # Gets the current group from the DslContext
     def current_group
-      @group_stack.last
+        DslContext.current_group
     end
 
     # Manages the entry in a new group:
-    # * create a new Group instance
-    # * define a method in the current group to access this new group
-    # * push the new group instance on top of the group stack 
-    # @param [#to_s] name of the new group
+    # * create a new Group instance (or retrieve it if it already exists in the current context)
+    # * define a method in the current group to access the new group
+    # * notify the context about the entry in a new group
+    # @param [#to_s] name name of the new group
     #
     def enter_group(name)
       group = group_in_current_context(name) || Group.new(name)
       define_method_in_current_group(name) {group}
-      @group_stack.push(group)
+      DslContext.enter_group(group)
     end
 
     # Defines a method inside the current group
@@ -102,43 +213,32 @@ module Templator
     # @param [Block] method_block block of the méthode to define
     def define_method_in_current_group(method_name, &method_block)
       (class << current_group; self; end).send(:define_method, method_name, method_block)
-  end
+    end
 
-  # Verify if a group belongs to the current group
-  # @param [#to_s] name name of the group to control
-  # @return the group with the given name if it belongs to the current group, nil otherwise
-  def group_in_current_context(name)
-    current_group.respond_to?(name) ? current_group.send(name) : nil
-  end
+    # Verify if a group belongs to the current group
+    # @param [#to_s] name name of the group to control
+    # @return the group with the given name if it belongs to the current group, nil otherwise
+    def group_in_current_context(name)
+      current_group.respond_to?(name) ? current_group.send(name) : nil
+    end
 
-  # Manages the exit from a group
-  def leave_group
-    @group_stack.pop
-  end
+    # Manages the exit from a group
+    def leave_group
+      DslContext.leave_group
+    end
 
-  # Manages the access to a parameter outside of the current group
-  def method_missing(name, *args)
-    @group_stack.first.send(name, *args)
-  end
+    # Manages the access to a parameter outside of the current group
+    def method_missing(name, *args)
+      DslContext.top_level_group.send(name, *args)
+    end
 
-  # Get a group from its fully qualified name
-  def get_group(fully_qualified_name)
-    fully_qualified_name.to_s.split('.').inject(top_level_group) {|result, name| result.send(name)}
-  end
+    # Get a group from its fully qualified name
+    def get_group(fully_qualified_name)
+      fully_qualified_name.to_s.split('.').inject(DslContext.top_level_group) {|result, name| result.send(name)}
+    end
 
-  # Return the top level goup
-  def top_level_group
-    @group_stack.first
   end
-
 end
 
-# Base class to define a group.
-# A Group instance is created whenever a group method is parsed from the DSL code.
-# Methods are dynamically created inside the singleton of the instance to access nested parameters and groups.
-class Group
-  def initialize(name)
-    @name = name
-  end
-end
-end
+#inject the DSL methos in the main object
+extend Templator::DslMethods