templator 0.1

data/lib/templator/parameter_code_loader.rb

@@ -0,0 +1,51 @@
+module Templator
+
+  class ParameterCodeLoader
+
+    def self.load_code_from(*paths)
+      files = get_candidate_files paths
+      code = concatenate_content_of files
+    end
+
+    private 
+
+    # Identifies all candidate files from the given array of paths.
+    # A path may match a file or a directory. 
+    # The method considers as candidates :
+    #  * all paths that match a regular file
+    #  * all files at the root of a directory when the path match a directory
+    # @param [Array<String>] paths list of paths
+    # @return [Array<String>] array of candidate files.
+    def self.get_candidate_files(paths)
+      candidates = []
+      paths.each do |path|
+        if File.directory?(path)
+          candidates.concat(get_files_from_directory(path))
+        else
+          candidates << path
+        end
+      end
+      return candidates
+    end
+
+    # Lists files at the root of the given directory path
+    # @param [String] directory path of the directory to process
+    # @return [Array<String>] array of files included at the top level of the directory
+    def self.get_files_from_directory(directory)
+      Dir["#{directory}/*"].sort.select do |file|
+        File.file? file
+      end
+    end
+
+    # Concatenates the content of the given files.
+    # @param [Array<String>] files array of files to process
+    # @return [String] the content concatenated of all given files
+    def self.concatenate_content_of(files)
+      files.inject("") do |content, file| 
+        content += File.read(file) 
+        content += "\n" unless content[-1, 1] == "\n"
+        content
+      end
+    end
+  end
+end

data/lib/templator/parameter_dsl.rb

@@ -0,0 +1,144 @@
+module Templator
+
+  # Defines and interprets the methods of 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
+  # * include_group(name) : include parameters and sub groups the given group into the current group
+  #
+  # =Example
+  # With the following code :
+  #  export :param1 => 'value1'
+  #  export :param2 => 'value2', :param3 => 'value3'
+  #  group "group1" do
+  #    export :param4 => value4
+  #  end
+  #  group "group2" do
+  #    export :param5 => group1.param4
+  #    group "group3" do
+  #      export :param6 => "value6"
+  #    end
+  #  end  
+  #  group "group4" do
+  #    include_group "group2.group3"
+  #  end
+  #
+  #
+  # param5 value can retrieved with the following :
+  #  p = ParameterDsl.new.parse(code)
+  #  p.group2.param5
+  #
+  #
+  class ParameterDsl
+
+    # Name of the implicit top level group
+    TOP_LEVEL_GROUP_NAME = "__top__"
+
+    def initialize
+      #initialize the top level group
+      @group_stack = []
+      @group_stack.push Group.new(TOP_LEVEL_GROUP_NAME)
+    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
+    end
+
+    # Defines parameters providing a name and a value for each parameter.
+    # @param [Hash]params hash of parameter name and value 
+    def export(params)
+      params.each do |name, value| 
+        define_method_in_current_group(name) {value}
+      end
+    end
+
+    # Defines a group of parameters.
+    # @param [#to_s] name name of the group
+    # @yield group block definition
+    def group(name)
+      enter_group name.to_s
+      yield
+      leave_group
+    end
+
+    # Includes all parameters and sub groups of a given group into the current group.
+    # @param [Group,#to_s] group group to include
+    def include_group(group)
+      source_group = group
+      if ! group.kind_of? Group
+        source_group = get_group group.to_s
+      end
+      source_group.singleton_methods.each do |method|
+        define_method_in_current_group(method) {source_group.send(method)}
+      end
+    end
+
+    private
+
+    # Gets the current group from the group stack
+    def current_group
+      @group_stack.last
+    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
+    #
+    def enter_group(name)
+      group = group_in_current_context(name) || Group.new(name)
+      define_method_in_current_group(name) {group}
+      @group_stack.push(group)
+    end
+
+    # Defines a method inside the current group
+    # @param [#to_s] method_name name of the method to define.
+    # @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
+
+  # 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 access to a parameter outside of the current group
+  def method_missing(name, *args)
+    @group_stack.first.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
+
+  # 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

data/lib/templator/parameters.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'templator/parameter_code_loader'
+require 'templator/parameter_dsl'
+
+module Templator
+
+  class Parameters
+
+    # Loads parameter files from given paths.
+    #
+    # @param [Array<String>] paths list of paths that match parameter files.
+    #   Each element can match an individual file or a directory, in this case
+    #   all files included at the root of this directory are assumed to be 
+    #   parameter files.
+    # 
+    # @return [Parameters] a Parameters instance.
+    #  This instance is suitable to provide a later access 
+    #  to parameters defined in loaded files.
+    def self.load_files(*paths)
+
+      code = ParameterCodeLoader.load_code_from(*paths)
+
+      parameters = Parameters.new
+      parameters.load(code)
+      return parameters
+    end
+
+    # Retrieves the value of a variable
+    # defined in the parameter files previously loaded
+    # @param [#to_s] var the fully qualified name of the variable (in dot notation)
+    def get(var)
+      var.to_s.split('.').inject(@parameters) {|result, element| result.send(element)} 
+    end
+
+    # Loads code in a fresh context
+    # @param [String ] code code to load
+    def load(code)
+      @parameters = Templator::ParameterDsl.new.parse(code)
+    end
+  end
+end

data/spec/templator/actions_spec.rb

@@ -0,0 +1,97 @@
+require 'templator/actions'
+
+module Templator
+
+  describe Actions do
+
+    # test class
+    class Includer
+      include Actions
+
+      def initialize
+        @context = nil
+      end
+
+      def context
+        return @context
+      end
+
+      def context=(context)
+        @context = context
+      end
+
+    end
+
+    before do
+      @includer = Includer.new
+      @varname = "foo"
+      @varvalue = "bar"
+    end
+
+    describe "#param" do
+
+      context ", when no context is provided," do
+        it "should retrieve from the #parameters instance the value of the provided parameter name" do
+
+          parameters = mock(:parameters)
+
+          @includer.should_receive(:parameters).once.and_return(parameters)
+          parameters.should_receive(:get).with(@varname).once.and_return(@varvalue)
+
+          @includer.param(@varname).should == @varvalue
+
+        end
+      end
+
+      context ", when a context is defined in the includer" do
+
+        before do
+            @parameters = mock(:parameters)
+
+            @context_name = "context"
+            @includer.context = @context_name
+        end
+
+        context "and the provided parameter is defined outside of the context," do
+
+          it "should retrieve the value of the provided parameter name from #parameters" do
+
+            @includer.should_receive(:parameters).once.and_return(@parameters)
+            @parameters.should_receive(:get).with(@varname).once.and_return(@varvalue)
+
+            @includer.param(@varname).should == @varvalue
+
+          end
+        end
+
+        context "and the provided variable is defined inside of the context," do
+          it "should retrieve the value of the provided parameter name from #parameters" do
+
+            @includer.should_receive(:parameters).at_least(:once).and_return(@parameters)
+            @parameters.should_receive(:get).with(any_args).twice.and_return do |varname|
+              case varname
+              when @varname
+                raise NoMethodError.new
+              when "#{@context_name}.#{@varname}"
+                @varvalue
+              end
+            end
+
+            @includer.param(@varname).should == @varvalue
+          end
+        end
+      end
+    end
+
+    describe "#include_file" do
+
+      it "should include a file relative to the current template file" do
+
+        test_file = File.expand_path('file_to_include', File.join(File.dirname(__FILE__),'../data'))
+
+        @includer.should_receive(:search_path).once.and_return([File.dirname(test_file)])
+        @includer.include_file(File.basename(test_file)).should == File.new(test_file).read
+      end
+    end
+  end
+end

data/spec/templator/parameter_code_loader_spec.rb

@@ -0,0 +1,29 @@
+require 'templator/parameter_code_loader'
+require 'spec_helper'
+
+
+module Templator
+
+  describe "ParameterCodeLoader" do
+
+    describe "#parameter_loader" do
+
+      it "should load the code from the given file" do
+
+        path = File.join(parameter_dir_path, 'parameter1')
+
+        code = ParameterCodeLoader.load_code_from(path)
+  
+        code.should == parameter_file_content(path)
+
+
+      end
+
+      it "should load the code from all the files inside the given directory" do
+        code = ParameterCodeLoader.load_code_from(parameter_dir_path)
+        code.should == parameter_file_content(*Dir["#{parameter_dir_path}/*"])
+      end
+    end
+
+  end
+end

data/spec/templator/parameter_dsl_spec.rb

@@ -0,0 +1,133 @@
+require 'templator/parameter_dsl'
+
+module Templator
+
+  describe ParameterDsl do
+
+    describe "#parse" do
+
+      context "when the DSL defines a parameter" do
+
+        it "should return an object that allows to access the parameter value in a natural way" do
+
+          code =<<-CODE
+          export :var1 => "value1"
+          CODE
+
+          pdsl = ParameterDsl.new
+          group = pdsl.parse(code)
+
+          group.var1.should == "value1"
+        end
+      end
+
+      context "when the DSL defines a group and a parameter inside this group" do
+
+        it "should return an object that allows to access the parameter value in a natural way" do
+          code = <<-CODE
+          group "group1" do
+            export :var2 => "value2"
+          end
+          CODE
+
+          pdsl = ParameterDsl.new
+          group = pdsl.parse(code)
+
+          group.group1.var2.should == "value2"
+        end
+      end
+
+      context "when the DSL defines a parameter for which the value is a parameter from another group" do
+
+        it "should return an object that allows to access the parameter value in a natural way" do
+          code = <<-CODE
+          group "group3" do
+            export :var3 => "value3"
+          end
+
+          group "group4" do
+            export :var4 => group3.var3
+          end
+          CODE
+
+
+          pdsl = ParameterDsl.new
+          group = pdsl.parse(code)
+
+          group.group4.var4.should == group.group3.var3
+        end
+      end
+
+      context "when the DSL ask to mix a group into the current group" do
+
+        let (:code) { 
+          <<-CODE
+          group "source" do
+            group "subgroup" do
+              export :var_in_subgroup => "value_in_subgroup"
+            end
+            export :var_in_group => "value_in_group"
+          end
+          CODE
+        }
+
+        context "and the group to include is given as a String" do
+
+          it "should include in the current group all parameters and sub groups defined in the source group" do
+
+            my_code = code + <<-CODE
+            group :target do 
+              include_group "source"
+            end
+            CODE
+
+            pdsl = ParameterDsl.new
+            group = pdsl.parse(my_code)
+
+            group.target.subgroup.var_in_subgroup.should == "value_in_subgroup"
+            group.target.var_in_group.should == "value_in_group"
+
+          end
+        end
+
+        context "and the group to include is given as a Group" do
+
+          it "should include in the current group all parameters and sub groups defined in the source group" do
+            my_code = code + <<-CODE
+            group :target do 
+              include_group source
+            end
+            CODE
+
+            pdsl = ParameterDsl.new
+            group = pdsl.parse(my_code)
+
+            group.target.subgroup.var_in_subgroup.should == "value_in_subgroup"
+            group.target.var_in_group.should == "value_in_group"
+          end
+        end
+      end
+
+      context "when a group is defined twice" do
+
+        it "should merge the definition of each group into a single one" do
+          my_code = <<-CODE
+          group :group1 do
+            export :var1 => "value1"
+          end
+
+          group :group1 do
+            export :var2 => "value2"
+          end
+          CODE
+
+          pdsl = ParameterDsl.new
+          group = pdsl.parse(my_code)
+
+          group.group1.var1.should == "value1"
+          group.group1.var2.should == "value2"
+        end
+      end
+    end
+  end
+end