buildr 1.3.2 → 1.3.3

data/lib/buildr/core/build.rb

@@ -27,7 +27,7 @@ module Buildr
     # Runs the build in parallel when true (defaults to false). You can force a parallel build by
     # setting this option directly, or by running the parallel task ahead of the build task.
     #
-    # This option only affects recurvise tasks. For example:
+    # This option only affects recursive tasks. For example:
     #   buildr parallel package
     # will run all package tasks (from the sub-projects) in parallel, but each sub-project's package
     # task runs its child tasks (prepare, compile, resources, etc) in sequence.
@@ -48,7 +48,7 @@ module Buildr
       desc 'Clean files generated during a build'
       Project.local_task('clean') { |name| "Cleaning #{name}" }
 
-      desc 'The default task it build'
+      desc 'The default task is build'
       task 'default'=>'build'
     end
 
@@ -109,146 +109,195 @@ module Buildr
   end
 
 
+  class Svn
+
+    class << self
+      def commit(file, message)
+        svn 'commit', '-m', message, file
+      end
+      
+      def copy(dir, url, message)
+        svn 'copy', dir, url, '-m', message
+      end
+      
+      # Return the current SVN URL
+      def repo_url
+        svn('info').scan(/URL: (.*)/)[0][0]
+      end
+      
+      def remove(url, message)
+        svn 'remove', url, '-m', message
+      end
+      
+      # Status check reveals modified files, but also SVN externals which we can safely ignore.
+      def uncommitted_files
+        svn('status', '--ignore-externals').reject { |line| line =~ /^X\s/ }
+      end
+      
+      # :call-seq:
+      #   svn(*args)
+      #
+      # Executes SVN command and returns the output.
+      def svn(*args)
+        cmd = 'svn ' + args.map { |arg| arg[' '] ? %Q{"#{arg}"} : arg }.join(' ')
+        trace cmd
+        `#{cmd}`.tap { fail 'SVN command failed' unless $?.exitstatus == 0 }
+      end
+    end
+  end
+  
+  
   class Release
 
-    THIS_VERSION_PATTERN  = /THIS_VERSION|VERSION_NUMBER\s*=\s*(["'])(.*)\1/
-    NEXT_VERSION_PATTERN  = /NEXT_VERSION\s*=\s*(["'])(.*)\1/
+    THIS_VERSION_PATTERN  = /(THIS_VERSION|VERSION_NUMBER)\s*=\s*(["'])(.*)\2/
 
     class << self
+      
+      # Use this to specify a different tag name for tagging the release in source control.
+      # You can set the tag name or a proc that will be called with the version number,
+      # for example:
+      #   Release.tag_name = lambda { |ver| "foo-#{ver}" }
+      attr_accessor :tag_name
 
       # :call-seq:
       #   make()
       #
       # Make a release.
-      def make()
+      def make
         check
-        version = with_next_version do |filename, version| 
-          options = ['--buildfile', filename, 'DEBUG=no']
+        with_release_candidate_version do |release_candidate_buildfile| 
+          options = ['--buildfile', release_candidate_buildfile, 'DEBUG=no']
           options << '--environment' << Buildr.environment unless Buildr.environment.to_s.empty?
-          sh "#{command} _#{Buildr::VERSION}_ clean upload #{options.join(' ')}"
+          buildr %w{clean upload}, options
         end
-        tag version
-        commit version + '-SNAPSHOT'
+        tag_release
+        commit_new_snapshot
       end
 
-    protected
-
-      def command() #:nodoc:
-        Config::CONFIG['arch'] =~ /dos|win32/i ? $PROGRAM_NAME.ext('cmd') : $PROGRAM_NAME
+      # :call-seq:
+      #   extract_version() => this_version
+      #
+      # Extract the current version number from the buildfile.
+      # Raise an error if not found.
+      def extract_version
+        buildfile = File.read(Buildr.application.buildfile.to_s)
+        buildfile.scan(THIS_VERSION_PATTERN)[0][2]
+      rescue
+        fail 'Looking for THIS_VERSION = "..." in your Buildfile, none found'
       end
-
+      
+      # :call-seq:
+      #   tag_url(svn_url, version) => tag_url
+      #
+      # Returns the SVN url for the tag.
+      # Can tag from the trunk or from branches.
+      # Can handle the two standard repository layouts.
+      #   - http://my.repo/foo/trunk => http://my.repo/foo/tags/1.0.0
+      #   - http://my.repo/trunk/foo => http://my.repo/tags/foo/1.0.0
+      def tag_url(svn_url, version)
+        trunk_or_branches = Regexp.union(%r{^(.*)/trunk(.*)$}, %r{^(.*)/branches(.*)/([^/]*)$})
+        match = trunk_or_branches.match(svn_url)
+        prefix = match[1] || match[3]
+        suffix = match[2] || match[4]
+        tag = tag_name || version
+        tag = tag.call(version) if Proc === tag
+        prefix + '/tags' + suffix + '/' + tag
+      end
+      
       # :call-seq:
       #   check()
       #
       # Check that we don't have any local changes in the working copy. Fails if it finds anything
       # in the working copy that is not checked into source control.
-      def check()
-        fail "SVN URL must end with 'trunk' or 'branches/...'" unless svn_url =~ /(trunk)|(branches.*)$/
-        # Status check reveals modified file, but also SVN externals which we can safely ignore.
-        status = svn('status', '--ignore-externals').reject { |line| line =~ /^X\s/ }
-        fail "Uncommitted SVN files violate the First Principle Of Release!\n#{status}" unless
-          status.empty?
+      def check
+        fail "SVN URL must contain 'trunk' or 'branches/...'" unless Svn.repo_url =~ /(trunk)|(branches.*)$/
+        fail "Uncommitted SVN files violate the First Principle Of Release!\n#{Svn.uncommitted_files}" unless Svn.uncommitted_files.empty?
       end
 
+    protected
+
       # :call-seq:
-      #   with_next_version() { |filename| ... } => version
+      #   buildr(tasks, options)
       #
-      # Yields to block with upgraded version number, before committing to use it. Returns the *new*
-      # current version number.
+      # Calls another instance of buildr.
+      def buildr(tasks, options)
+          sh "#{command} _#{Buildr::VERSION}_ #{tasks.join(' ')} #{options.join(' ')}"
+      end
+      
+      def command #:nodoc:
+        Config::CONFIG['arch'] =~ /dos|win32/i ? $PROGRAM_NAME.ext('cmd') : $PROGRAM_NAME
+      end
+
+      # :call-seq:
+      #   with_release_candidate_version() { |filename| ... }
+      #
+      # Yields to block with release candidate buildfile, before committing to use it.
       #
       # We need a Buildfile with upgraded version numbers to run the build, but we don't want the
-      # Buildfile modified unless the build succeeds. So this method updates the version numbers in
+      # Buildfile modified unless the build succeeds. So this method updates the version number in
       # a separate (Buildfile.next) file, yields to the block with that filename, and if successful
       # copies the new file over the existing one.
       #
-      # Version numbers are updated as follows. The next release version becomes the current one,
-      # and the next version is upgraded by one to become the new next version. So:
-      #   THIS_VERSION = 1.1.0
-      #   NEXT_VERSION = 1.2.0
+      # The release version is the current version without '-SNAPSHOT'.  So:
+      #   THIS_VERSION = 1.1.0-SNAPSHOT
       # becomes:
-      #   THIS_VERSION = 1.2.0
-      #   NEXT_VERSION = 1.2.1
-      # and the method will return 1.2.0.
-      def with_next_version()
-        new_filename = Buildr.application.buildfile + '.next'
-        modified = change_version do |this_version, next_version|
-          one_after = next_version.split('.')
-          one_after[-1] = one_after[-1].to_i + 1
-          [ next_version, one_after.join('.') ]
-        end
-        File.open(new_filename, 'w') { |file| file.write modified }
+      #   THIS_VERSION = 1.1.0
+      # for the release buildfile.
+      def with_release_candidate_version
+        release_candidate_buildfile = Buildr.application.buildfile.to_s + '.next'
+        release_candidate_buildfile_contents = change_version { |version| version[-1] = version[-1].to_i }
+        File.open(release_candidate_buildfile, 'w') { |file| file.write release_candidate_buildfile_contents }
         begin
-          yield new_filename
-          mv new_filename, Buildr.application.buildfile
+          yield release_candidate_buildfile
+          mv release_candidate_buildfile, Buildr.application.buildfile.to_s
         ensure
-          rm new_filename rescue nil
+          rm release_candidate_buildfile rescue nil
         end
-        File.read(Buildr.application.buildfile).scan(THIS_VERSION_PATTERN)[0][1]
       end
 
       # :call-seq:
-      #   change_version() { |this, next| ... } => buildfile
+      #   change_version() { |this_version| ... } => buildfile
       #
-      # Change version numbers in the current Buildfile, but without writing a new file (yet).
-      # Returns the contents of the Buildfile with the modified version numbers.
+      # Change version number in the current Buildfile, but without writing a new file (yet).
+      # Returns the contents of the Buildfile with the modified version number.
       #
-      # This method yields to the block with the current (this) and next version numbers and expects
-      # an array with the new this and next version numbers.
-      def change_version()
-        buildfile = File.read(Buildr.application.buildfile)
-        this_version = buildfile.scan(THIS_VERSION_PATTERN)[0][1] or
-          fail "Looking for THIS_VERSION = \"...\" in your Buildfile, none found"
-        next_version = buildfile.scan(NEXT_VERSION_PATTERN)[0][1] or
-          fail "Looking for NEXT_VERSION = \"...\" in your Buildfile, none found"
-        this_version, next_version = yield(this_version, next_version)
-        if verbose
-          puts 'Upgrading version numbers:'
-          puts "  This:  #{this_version}"
-          puts "  Next:  #{next_version}"
-        end
-        buildfile.gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{this_version}"}) }.
-          gsub(NEXT_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{next_version}"}) }
+      # This method yields to the block with the current (this) version number as an array and expects
+      # the block to update it.
+      def change_version
+        this_version = extract_version
+        new_version = this_version.split('.')
+        yield(new_version)
+        new_version = new_version.join('.')
+        buildfile = File.read(Buildr.application.buildfile.to_s)
+        buildfile.gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{new_version}"}) }
       end
 
       # :call-seq:
-      #   tag(version)
+      #   tag_release()
       #
       # Tags the current working copy with the release version number.
-      def tag(version)
-        url = svn_url.sub(/(trunk$)|(branches.*)$/, "tags/#{version}")
-        svn 'remove', url, '-m', 'Removing old copy' rescue nil
-        svn 'copy', Dir.pwd, url, '-m', "Release #{version}"
+      def tag_release
+        version = extract_version
+        info "Tagging release #{version}"
+        url = tag_url Svn.repo_url, version
+        Svn.remove url, 'Removing old copy' rescue nil
+        Svn.copy Dir.pwd, url, "Release #{version}"
       end
 
       # :call-seq:
-      #   commit(version)
+      #   commit_new_snapshot()
       #
-      # Last, we commit what we currently have in the working copy.
-      def commit(version)
-        buildfile = File.read(Buildr.application.buildfile).
-          gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{version}"}) }
-        File.open(Buildr.application.buildfile, 'w') { |file| file.write buildfile }
-        svn 'commit', '-m', "Changed version number to #{version}", Buildr.application.buildfile
-      end
-
-      # :call-seq:
-      #   svn(*args)
-      #
-      # Executes SVN command and returns the output.
-      def svn(*args)
-        cmd = 'svn ' + args.map { |arg| arg[' '] ? %Q{"#{arg}"} : arg }.join(' ')
-        puts cmd if verbose
-        `#{cmd}`.tap { fail 'SVN command failed' unless $?.exitstatus == 0 }
-      end
-
-      # Return the current SVN URL
-      def svn_url
-        url = svn('info').scan(/URL: (.*)/)[0][0]
+      # Last, we commit what we currently have in the working copy with an upgraded version number.
+      def commit_new_snapshot
+        buildfile = change_version { |version| version[-1] = (version[-1].to_i + 1).to_s + '-SNAPSHOT' }
+        File.open(Buildr.application.buildfile.to_s, 'w') { |file| file.write buildfile }
+        Svn.commit Buildr.application.buildfile.to_s, "Changed version number to #{extract_version}"
+        info "Current version is now #{extract_version}"
       end
     end
-
   end
 
+  
   desc 'Make a release'
   task 'release' do |task|
     Release.make

data/lib/buildr/core/checks.rb

@@ -16,7 +16,7 @@
 
 require 'buildr/core/project'
 require 'buildr/packaging/zip'
-require 'test/unit'
+#require 'test/unit'
 require 'spec/matchers'
 require 'spec/expectations'
 
@@ -130,7 +130,7 @@ module Buildr
         # Run the expectation. We only print the expectation name when tracing (to know they all ran),
         # or when we get a failure.
         begin
-          puts description if Buildr.application.options.trace
+          trace description
           klass.new.instance_eval &@block
         rescue Exception=>error
           raise error.exception("#{description}\n#{error}").tap { |wrapped| wrapped.set_backtrace(error.backtrace) }
@@ -149,10 +149,10 @@ module Buildr
           begin
             expect.run_against project
             passed
-          rescue Exception=>error
+          rescue Exception=>ex
             if verbose
-              puts error.backtrace.detect { |line| line =~ /#{Buildr.application.buildfile}/ } || ""
-              puts error
+              error ex.backtrace.select { |line| line =~ /#{Buildr.application.buildfile}/ }.join("\n")
+              error ex
             end
             false
           end

data/lib/buildr/core/common.rb

@@ -111,7 +111,7 @@ module Buildr
       # Download to a file created by the task.
       fail unless args.keys.size == 1
       uri = URI.parse(args.values.first.to_s)
-      file(args.keys.first).tap do |task|
+      file(args.keys.first.to_s).tap do |task|
         task.sources << uri
         task.enhance { uri.download task.name }
       end

data/lib/buildr/core/compile.rb

@@ -122,6 +122,8 @@ module Buildr
         map = compile_map(sources, target)
         return false if map.empty?
         return true unless File.exist?(target.to_s)
+        source_files_not_yet_compiled = map.select { |source, target| !File.exist?(target) }
+        trace "Compile needed because source file #{source_files_not_yet_compiled[0][0]} has no corresponding #{source_files_not_yet_compiled[0][1]}" unless source_files_not_yet_compiled.empty?
         return true if map.any? { |source, target| !File.exist?(target) || File.stat(source).mtime > File.stat(target).mtime }
         oldest = map.map { |source, target| File.stat(target).mtime }.min
         return dependencies.any? { |path| file(path).timestamp > oldest }
@@ -173,7 +175,7 @@ module Buildr
             FileList["#{source}/**/*.{#{ext_glob}}"].reject { |file| File.directory?(file) }.
               each { |file| map[file] = File.join(target, Util.relative_path(file, source).ext(target_ext)) }
           else
-            map[source] = File.join(target, File.basename(source).ext(target_ext))
+            map[source] = target # File.join(target, File.basename(source).ext(target_ext))
           end
           map
         end
@@ -223,7 +225,7 @@ module Buildr
           raise 'No compiler selected and can\'t determine which compiler to use' unless compiler
           raise 'No target directory specified' unless target
           mkpath target.to_s, :verbose=>false
-          puts "Compiling #{task.name.gsub(/:[^:]*$/, '')} into #{target.to_s}" if verbose
+          info "Compiling #{task.name.gsub(/:[^:]*$/, '')} into #{target.to_s}"
           @compiler.compile(sources.map(&:to_s), target.to_s, dependencies.map(&:to_s))
           # By touching the target we let other tasks know we did something,
           # and also prevent recompiling again for dependencies.
@@ -244,6 +246,7 @@ module Buildr
     #   compile.from('src/java').into('classes').with('module1.jar')
     def from(*sources)  
       @sources |= sources.flatten
+      guess_compiler if @compiler.nil? && sources.flatten.any? { |source| File.exist?(source) }
       self
     end
 
@@ -316,10 +319,7 @@ module Buildr
     # based on existing source directories (e.g. src/main/java), or by requesting
     # a specific compiler (see #using).
     def compiler
-      unless @compiler
-        candidate = Compiler.compilers.detect { |cls| cls.applies_to?(project, self) }
-        self.compiler = candidate if candidate
-      end
+      guess_compiler unless @compiler
       @compiler && @compiler.class.to_sym
     end
 
@@ -363,7 +363,11 @@ module Buildr
     # Associates this task with project and particular usage (:main, :test).
     def associate_with(project, usage) #:nodoc:
       @project, @usage = project, usage
-      # Try to guess if we have a compiler to match source files.
+      guess_compiler
+    end
+    
+    # Try to guess if we have a compiler to match source files.
+    def guess_compiler #:nodoc:
       candidate = Compiler.compilers.detect { |cls| cls.applies_to?(project, self) }
       self.compiler = candidate if candidate
     end
@@ -496,9 +500,7 @@ module Buildr
         # This comes last because the target path is set inside the project definition.
         project.build project.compile.target
         project.clean do
-          verbose(false) do
-            rm_rf project.compile.target.to_s
-          end
+          rm_rf project.compile.target.to_s, :verbose=>false
         end
       end
     end

data/lib/buildr/core/filter.rb

@@ -13,7 +13,6 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-
 module Buildr
 
   # A filter knows how to copy files from one directory to another, applying mappings to the
@@ -56,7 +55,8 @@ module Buildr
     def clear
       @include = []
       @exclude = []
-      @sources = []
+      @sources = FileList[]
+      @mapper = Mapper.new
       self
     end
 
@@ -93,7 +93,7 @@ module Buildr
     # Specifies files to include and returns self. See FileList#include.
     #
     # By default all files are included. You can use this method to only include specific
-    # files form the source directory.
+    # files from the source directory.
     def include(*files)
       @include += files
       self
@@ -110,10 +110,14 @@ module Buildr
     end
 
     # The mapping. See #using.
-    attr_accessor :mapping
+    def mapping #:nodoc:
+      @mapper.config
+    end
 
     # The mapper to use. See #using.
-    attr_accessor :mapper
+    def mapper #:nodoc:
+      @mapper.mapper_type
+    end
 
     # :call-seq:
     #   using(mapping) => self
@@ -127,6 +131,7 @@ module Buildr
     # * :ant -- Map <code>@key@</code>.
     # * :maven -- Map <code>${key}</code> (default).
     # * :ruby -- Map <code>#{key}</code>.
+    # * :erb -- Map <code><%= key %></code>.
     # * Regexp -- Maps the matched data (e.g. <code>/=(.*?)=/</code>
     #
     # For example:
@@ -138,20 +143,10 @@ module Buildr
     # to return the mapped content.
     #
     # Without any mapping, all files are copied as is.
+    #
+    # To register new mapping type see the Mapper class.
     def using(*args, &block)
-      case args.first
-      when Hash # Maven hash mapping
-        using :maven, *args
-      when Symbol # Mapping from a method
-        raise ArgumentError, 'Expected mapper type followed by mapping hash' unless args.size == 2 && Hash === args[1]
-        @mapper, @mapping = *args
-      when Regexp # Mapping using a regular expression
-        raise ArgumentError, 'Expected regular expression followed by mapping hash' unless args.size == 2 && Hash === args[1]
-        @mapper, @mapping = *args
-      else
-        raise ArgumentError, 'Expected proc, method or a block' if args.size > 1 || (args.first && block)
-        @mapping = args.first || block
-      end
+      @mapper.using(*args, &block)
       self
     end
 
@@ -185,24 +180,12 @@ module Buildr
             mkpath dest
           else
             mkpath File.dirname(dest)
-            case mapping
-            when Proc, Method # Call on input, accept output.
-              mapped = mapping.call(path, File.open(source, 'rb') { |file| file.read })
+            if @mapper.mapper_type
+              mapped = @mapper.transform(File.open(source, 'rb') { |file| file.read }, path)
               File.open(dest, 'wb') { |file| file.write mapped }
-            when Hash # Map ${key} to value
-              content = File.open(source, 'rb') { |file| file.read }
-              if Symbol === @mapper
-                mapped = send("#{@mapper}_mapper", content) { |key| mapping[key] }
-              else
-                mapped = regexp_mapper(content) { |key| mapping[key] }
-              end
-                #gsub(/\$\{[^}]*\}/) { |str| mapping[str[2..-2]] || str }
-                File.open(dest, 'wb') { |file| file.write mapped }
-            when nil # No mapping.
+            else # no mapping
               cp source, dest
               File.chmod(0664, dest)
-            else
-              fail "Filter can be a hash (key=>value), or a proc/method; I don't understand #{mapping}"
             end
           end
         end
@@ -216,23 +199,145 @@ module Buildr
       @target.to_s
     end
 
-  private
+    # This class implements content replacement logic for Filter.
+    #
+    # To register a new template engine @:foo@, extend this class with a method like: 
+    # 
+    #   def foo_transform(content, path = nil)
+    #      # if this method yields a key, the value comes from the mapping hash
+    #      content.gsub(/world/) { |str| yield :bar }
+    #   end
+    #
+    # Then you can use :foo mapping type on a Filter
+    #   
+    #   filter.using :foo, :bar => :baz
+    #
+    # Or all by your own, simply
+    #
+    #   Mapper.new(:foo, :bar => :baz).transform("Hello world") # => "Hello baz"
+    # 
+    # You can handle configuration arguments by providing a @*_config@ method like:
+    # 
+    #   # The return value of this method is available with the :config accessor.
+    #   def moo_config(*args, &block)
+    #      raise ArgumentError, "Expected moo block" unless block_given?
+    #      { :moos => args, :callback => block }
+    #   end
+    #
+    #   def moo_transform(content, path = nil)
+    #      content.gsub(/moo+/i) do |str|
+    #        moos = yield :moos # same than config[:moos]
+    #        moo = moos[str.size - 3] || str
+    #        config[:callback].call(moo)
+    #      end
+    #   end
+    #
+    # Usage for the @:moo@ mapper would be something like:
+    # 
+    #   mapper = Mapper.new(:moo, 'ooone', 'twoo') do |str|
+    #     i = nil; str.capitalize.gsub(/\w/) { |s| s.send( (i = !i) ? 'upcase' : 'downcase' ) }
+    #   end
+    #   mapper.transform('Moo cow, mooo cows singing mooooo') # => 'OoOnE cow, TwOo cows singing MoOoOo'
+    class Mapper
 
-    def maven_mapper(content)
-      content.gsub(/\$\{.*?\}/) { |str| yield(str[2..-2]) || str }
-    end
+      attr_reader :mapper_type, :config
 
-    def ant_mapper(content)
-      content.gsub(/@.*?@/) { |str| yield(str[1..-2]) || str }
-    end
+      def initialize(*args, &block) #:nodoc:
+        using(*args, &block)
+      end
+      
+      def using(*args, &block)
+        case args.first
+        when Hash # Maven hash mapping
+          using :maven, *args
+        when Binding # Erb binding
+          using :erb, *args
+        when Symbol # Mapping from a method
+          raise ArgumentError, "Unknown mapping type: #{args.first}" unless respond_to?("#{args.first}_transform", true)
+          configure(*args, &block)
+        when Regexp # Mapping using a regular expression
+          raise ArgumentError, 'Expected regular expression followed by mapping hash' unless args.size == 2 && Hash === args[1]
+          @mapper_type, @config = *args
+        else
+          unless args.empty? && block.nil?
+            raise ArgumentError, 'Expected proc, method or a block' if args.size > 1 || (args.first && block)
+            @mapper_type = :callback
+            config = args.first || block
+            raise ArgumentError, 'Expected proc, method or callable' unless config.respond_to?(:call)
+            @config = config
+          end
+        end
+        self
+      end
 
-    def ruby_mapper(content)
-      content.gsub(/#\{.*?\}/) { |str| yield(str[2..-2]) || str }
-    end
+      def transform(content, path = nil)
+        type = Regexp === mapper_type ? :regexp : mapper_type
+        raise ArgumentError, "Invalid mapper type: #{type.inspect}" unless respond_to?("#{type}_transform", true)
+        self.__send__("#{type}_transform", content, path) { |key| config[key] || config[key.to_s.to_sym] }
+      end
 
-    def regexp_mapper(content)
-      content.gsub(@mapper) { |str| yield(str.scan(@mapper).join) || str }
-    end
+     private
+      def configure(mapper_type, *args, &block)
+        configurer = method("#{mapper_type}_config") rescue nil
+        if configurer
+          @config = configurer.call(*args, &block)
+        else
+          raise ArgumentError, "Missing hash argument after :#{mapper_type}" unless args.size == 1 && Hash === args[0]
+          @config = *args
+        end
+        @mapper_type = mapper_type
+      end
+
+      def maven_transform(content, path = nil)
+        content.gsub(/\$\{.*?\}/) { |str| yield(str[2..-2]) || str }
+      end
+      
+      def ant_transform(content, path = nil)
+        content.gsub(/@.*?@/) { |str| yield(str[1..-2]) || str }
+      end
+      
+      def ruby_transform(content, path = nil)
+        content.gsub(/#\{.*?\}/) { |str| yield(str[2..-2]) || str }
+      end
+      
+      def regexp_transform(content, path = nil)
+        content.gsub(mapper_type) { |str| yield(str.scan(mapper_type).join) || str }
+      end
+
+      def callback_transform(content, path = nil)
+        config.call(path, content)
+      end
+      
+      def erb_transform(content, path = nil)
+        case config
+        when Binding, Proc
+          bnd = config
+        when Method
+          bnd = config.to_proc
+        when Hash
+          bnd = OpenStruct.new
+          table = config.inject({}) { |h, e| h[e.first.to_sym] = e.last; h }
+          bnd.instance_variable_set(:@table, table)
+          bnd = bnd.instance_eval { binding }
+        else
+          bnd = config.instance_eval { binding }
+        end
+        require 'erb'
+        ERB.new(content).result(bnd)
+      end
+
+      def erb_config(*args, &block)
+        if block_given?
+          raise ArgumentError, "Expected block or single argument, but both given." unless args.empty?
+          block
+        elsif args.size > 1
+          raise ArgumentError, "Expected block or single argument."
+        else
+          args.first
+        end
+      end
+
+    end # class Mapper
 
   end