templater 0.1.6 → 0.2

data/lib/templater/discovery.rb

@@ -53,18 +53,25 @@ module Templater
     
     protected
     
-    def find_latest_gems
-      Gem::cache.inject({}) do |latest_gems, cache|
-        name, gem = cache
-        currently_latest = latest_gems[gem.name]
-        latest_gems[gem.name] = gem if currently_latest.nil? or gem.version > currently_latest.version
-        latest_gems
-      end.values
+    def find_latest_gem_paths
+      # Minigems provides a simpler (and much faster) method for finding the
+      # latest gems.
+      if Gem.respond_to?(:latest_gem_paths)
+        Gem.latest_gem_paths
+      else
+        gems = Gem.cache.inject({}) do |latest_gems, cache|
+          name, gem = cache
+          currently_latest = latest_gems[gem.name]
+          latest_gems[gem.name] = gem if currently_latest.nil? or gem.version > currently_latest.version
+          latest_gems
+        end
+        gems.values.map{|g| g.full_gem_path}
+      end
     end
 
     def generator_files
-      find_latest_gems.inject([]) do |files, gem|
-        path = ::File.join(gem.full_gem_path, "Generators")
+      find_latest_gem_paths.inject([]) do |files, gem_path|
+        path = ::File.join(gem_path, "Generators")
         files << path if ::File.exists?(path) and not ::File.directory?(path)
         files
       end

data/lib/templater/generator.rb

@@ -1,5 +1,7 @@
 module Templater
   
+  ACTION_RESERVED_OPTIONS = [:before, :after].freeze
+
   class Generator
     
     include Templater::CaptureHelpers
@@ -7,6 +9,7 @@ module Templater
     class << self
       
       attr_accessor :manifold
+
       
       # Returns an array of hashes, where each hash describes a single argument.
       #
@@ -14,56 +17,57 @@ module Templater
       # Array[Hash{Symbol=>Object}]:: A list of arguments
       def arguments; @arguments ||= []; end
       
+      # A shorthand method for adding the first argument, see +Templater::Generator.argument+
+      def first_argument(*args); argument(0, *args); end
+
+      # A shorthand method for adding the second argument, see +Templater::Generator.argument+
+      def second_argument(*args); argument(1, *args); end
+
+      # A shorthand method for adding the third argument, see +Templater::Generator.argument+
+      def third_argument(*args); argument(2, *args); end
+      
+      # A shorthand method for adding the fourth argument, see +Templater::Generator.argument+
+      def fourth_argument(*args); argument(3, *args); end
+
+
       # Returns an array of options, where each hash describes a single option.
       #
       # === Returns
       # Array[Hash{Symbol=>Object}]:: A list of options
       def options; @options ||= []; end
-      
-      # Returns an array of hashes, where each hash describes a single template.
-      #
-      # === Returns
-      # Array[Hash{Symbol=>Object}]:: A list of template
-      def templates; @templates ||= []; end
-      
-      # Returns an array of hashes, where each hash describes a single file.
-      #
-      # === Returns
-      # Array[Hash{Symbol=>Object}]:: A list of files
-      def files; @files ||= []; end
-      
+
       # Returns an array of hashes, where each hash describes a single invocation.
       #
       # === Returns
       # Array[Hash{Symbol=>Object}]:: A list of invocations
       def invocations; @invocations ||= []; end
+
       
-      # Returns an array of hashes, where each hash describes a single empty directory created by generator.
+      # Returns an Hash that maps the type of action to a list of ActionDescriptions.
       #
       # ==== Returns
-      # Array[Hash{Symbol=>Object}]:: A list of empty directories created by generator.
-      def empty_directories; @empty_directories ||= []; end
+      # Hash{Symbol=>Array[Templater::ActionDescription]}:: A Hash of actions
+      def actions; @actions ||= {} end
 
-
-
-      
+      # Returns an array of ActionDescriptions, where each describes a single template.
+      #
+      # === Returns
+      # Array[Templater::ActionDescription]:: A list of template descriptions.
+      def templates; actions[:templates] ||= []; end
       
-      # A shorthand method for adding the first argument, see +Templater::Generator.argument+
-      def first_argument(*args); argument(0, *args); end
-
-      # A shorthand method for adding the second argument, see +Templater::Generator.argument+
-      def second_argument(*args); argument(1, *args); end
-
-      # A shorthand method for adding the third argument, see +Templater::Generator.argument+
-      def third_argument(*args); argument(2, *args); end
+      # Returns an array of ActionDescriptions, where each describes a single file.
+      #
+      # === Returns
+      # Array[Templater::ActionDescription]:: A list of file descriptions.
+      def files; actions[:files] ||= []; end
       
-      # A shorthand method for adding the fourth argument, see +Templater::Generator.argument+
-      def fourth_argument(*args); argument(3, *args); end
-
-
+      # Returns an array of ActionDescriptions, where each describes a single empty directory created by generator.
+      #
+      # ==== Returns
+      # Array[Templater::ActionDescription]:: A list of empty directory descriptions.
+      def empty_directories; actions[:empty_directories] ||= []; end
 
 
-      
       # If the argument is omitted, simply returns the description for this generator, otherwise
       # sets the description to the passed string.
       #
@@ -96,11 +100,7 @@ module Templater
       # :required<Boolean>:: If set to true, the generator will throw an error if it initialized without this argument
       # :desc<Symbol>:: Provide a description for this argument
       def argument(n, name, options={}, &block)
-        self.arguments[n] = {
-          :name => name.to_sym,
-          :options => options,
-          :block => block
-        }
+        self.arguments[n] = ArgumentDescription.new(name.to_sym, options, &block)
         class_eval <<-CLASS
           def #{name}
             get_argument(#{n})
@@ -124,10 +124,7 @@ module Templater
       # :as<Symbol>:: If set to :boolean provides a hint to the interface using this generator.
       # :desc<Symbol>:: Provide a description for this option
       def option(name, options={})
-        self.options << {
-          :name => name.to_sym,
-          :options => options
-        }
+        self.options << Description.new(name.to_sym, options)
         class_eval <<-CLASS
           def #{name}
             get_option(:#{name})
@@ -178,11 +175,7 @@ module Templater
       #     invoke :other_generator, :amimal => :bear
       #   end
       def invoke(name, options={}, &block)
-        self.invocations << {
-          :name => name.to_sym,
-          :options => options,
-          :block => block
-        }
+        self.invocations << InvocationDescription.new(name.to_sym, options, &block)
       end
       
       # Adds a template to this generator. Templates are named and can later be retrieved by that name.
@@ -196,8 +189,8 @@ module Templater
       # Source and destination can be set in a block, which makes it possible to call instance methods to
       # determine the correct source and/or desination.
       #
-      # A hash of options can be passed, all of these options are matched against the options passed to the
-      # generator.
+      # A hash of options can be passed, these options are matched against the options passed to the
+      # generator. Some special options, for callbacks for example, are also supported, see below.
       #
       # === Parameters
       # name<Symbol>:: The name of this template
@@ -206,6 +199,10 @@ module Templater
       # options<Hash>:: Options for this template
       # &block<Proc>:: A block to execute when the generator is instantiated
       #
+      # === Options
+      # :before<Symbol>:: Name of a method to execute before this template is invoked
+      # :after<Symbol>:: Name of a method to execute after this template is invoked
+      #
       # ==== Examples
       #
       #   class MyGenerator < Templater::Generator
@@ -225,14 +222,11 @@ module Templater
         source, destination = args
         source, destination = source + 't', source if args.size == 1
         
-        self.templates << {
-          :name => name.to_sym,
-          :options => options,
-          :source => source,
-          :destination => destination,
-          :block => block,
-          :render => true
-        }
+        templates << ActionDescription.new(name, options) do |generator|
+          template = Actions::Template.new(generator, name, source, destination, options)
+          generator.instance_exec(template, &block) if block
+          template
+        end
       end
       
       # Adds a template that is not rendered using ERB, but copied directly. Unlike Templater::Generator.template
@@ -244,19 +238,20 @@ module Templater
       # destination<String>:: The destination where the result will be put.
       # options<Hash>:: Options for this template
       # &block<Proc>:: A block to execute when the generator is instantiated
+      #
+      # === Options
+      # :before<Symbol>:: Name of a method to execute before this template is invoked
+      # :after<Symbol>:: Name of a method to execute after this template is invoked
       def file(name, *args, &block)
         options = args.last.is_a?(Hash) ? args.pop : {}
         source, destination = args
         source, destination = source, source if args.size == 1
         
-        self.files << {
-          :name => name.to_sym,
-          :options => options,
-          :source => source,
-          :destination => destination,
-          :block => block,
-          :render => false
-        }
+        files << ActionDescription.new(name, options) do |generator|
+          file = Actions::File.new(generator, name, source, destination, options)
+          generator.instance_exec(file, &block) if block
+          file
+        end
       end
       
       # Adds an empty directory that will be created when the generator is run.
@@ -266,16 +261,19 @@ module Templater
       # destination<String>:: The destination where the empty directory will be created
       # options<Hash>:: Options for this empty directory
       # &block<Proc>:: A block to execute when the generator is instantiated
+      #
+      # === Options
+      # :before<Symbol>:: Name of a method to execute before this template is invoked
+      # :after<Symbol>:: Name of a method to execute after this template is invoked
       def empty_directory(name, *args, &block)
         options = args.last.is_a?(Hash) ? args.pop : {}
         destination = args.first
         
-        self.empty_directories << {
-          :name => name.to_sym,
-          :destination => destination,
-          :options => options,
-          :block => block
-        }
+        empty_directories << ActionDescription.new(name, options) do |generator|
+          directory = Actions::EmptyDirectory.new(generator, name, destination, options)
+          generator.instance_exec(directory, &block) if block
+          directory
+        end
       end
                        
       # An easy way to add many templates to a generator, each item in the list is added as a
@@ -356,15 +354,14 @@ module Templater
       # === Returns
       # Array[Templater::Generator]:: an array of generator classes.
       def generators
+        generators = [self]
         if manifold
-          generators = invocations.map do |i|
-            generator = manifold.generator(i[:name])
+          generators += invocations.map do |i|
+            generator = manifold.generator(i.name)
             generator ? generator.generators : nil
           end
-          generators.unshift(self).flatten.compact
-        else
-          [self]
         end
+        generators.flatten.compact
       end
       
       # This should return the directory where source templates are located. This method must be overridden in
@@ -401,10 +398,15 @@ module Templater
       
       # Initialize options to their default values.
       self.class.options.each do |option|
-        @options[option[:name]] ||= option[:options][:default]
+        @options[option.name] ||= option.options[:default]
       end
       
       extract_arguments(*args)
+
+      # Initialize arguments to their default values.
+      self.class.arguments.each_with_index do |argument, i|
+        @arguments[i] ||= argument.options[:default]
+      end
       
       valid_arguments?
     end
@@ -418,7 +420,7 @@ module Templater
     # === Returns
     # Templater::Actions::Template:: The found template.
     def template(name)
-      self.templates.find { |t| t.name == name }
+      templates.find { |t| t.name == name }
     end
     
     # Finds and returns the file of the given name. If that file's options don't match the generator
@@ -430,7 +432,7 @@ module Templater
     # === Returns
     # Templater::Actions::File:: The found file.
     def file(name)
-      self.files.find { |f| f.name == name }
+      files.find { |f| f.name == name }
     end
 
     # Finds and returns all empty directories whose options match the generator options.
@@ -438,7 +440,7 @@ module Templater
     # === Returns
     # [Templater::Actions::EmptyDirectory]:: The found empty directories that generator creates.
     def empty_directory(name)
-      self.empty_directories.find { |d| d.name == name }
+      empty_directories.find { |d| d.name == name }
     end
     
     # Finds and returns all templates whose options match the generator options.
@@ -446,10 +448,7 @@ module Templater
     # === Returns
     # [Templater::Actions::Template]:: The found templates.
     def templates
-      self.class.templates.inject([]) do |templates, template|
-        templates << Templater::Proxy.new(self, template).to_template if match_options?(template[:options])
-        templates
-      end
+      actions(:templates)
     end
     
     # Finds and returns all files whose options match the generator options.
@@ -457,10 +456,7 @@ module Templater
     # === Returns
     # [Templater::Actions::File]:: The found files.
     def files
-      self.class.files.inject([]) do |files, file|
-        files << Templater::Proxy.new(self, file).to_file if match_options?(file[:options])
-        files
-      end
+      actions(:files)
     end
 
     # Finds and returns all empty directories generator creates.
@@ -468,10 +464,7 @@ module Templater
     # === Returns
     # [Templater::Actions::File]:: The found files.
     def empty_directories
-      self.class.empty_directories.inject([]) do |empty_directories, action|
-        empty_directories << Templater::Proxy.new(self, action).to_empty_directory if match_options?(action[:options])
-        empty_directories
-      end
+      actions(:empty_directories)
     end    
     
     # Finds and returns all templates whose options match the generator options.
@@ -481,18 +474,20 @@ module Templater
     def invocations
       return [] unless self.class.manifold
       
-      self.class.invocations.inject([]) do |invocations, invocation|
-        generator = self.class.manifold.generator(invocation[:name])
-        
-        if generator and match_options?(invocation[:options])
-          
-          if invocation[:block]
-            invocations << instance_exec(generator, &invocation[:block])
-          else 
-            invocations << generator.new(destination_root, options, *@arguments)
-          end
-        end
-        invocations
+      self.class.invocations.map do |invocation|
+        invocation.get(self) if match_options?(invocation.options)
+      end.compact
+    end
+    
+    # Finds and returns all templates and files for this generators whose options match its options.
+    #
+    # === Returns
+    # [Templater::Actions::*]:: The found templates and files.
+    def actions(type=nil)
+      actions = type ? self.class.actions[type] : self.class.actions.values.flatten
+      actions.inject([]) do |actions, description|
+        actions << description.compile(self) if match_options?(description.options)
+        actions
       end
     end
     
@@ -501,15 +496,15 @@ module Templater
     #
     # === Returns
     # [Templater::Actions::File, Templater::Actions::Template]:: The found templates and files.
-    def actions
-      actions = templates + files + empty_directories
-      actions += invocations.map { |i| i.actions }
-      actions.flatten
+    def all_actions(type=nil)
+      all_actions = actions(type)
+      all_actions += invocations.map { |i| i.all_actions(type) }
+      all_actions.flatten
     end
     
     # Invokes the templates for this generator
     def invoke!
-      actions.each { |t| t.invoke! }
+      all_actions.each { |t| t.invoke! }
     end
     
     # Renders all actions in this generator. Use this to verify that rendering templates raises no errors.
@@ -517,7 +512,7 @@ module Templater
     # === Returns
     # [String]:: The results of the rendered actions
     def render!
-      actions.map { |t| t.render }
+      all_actions.map { |t| t.render }
     end
     
     # Returns this generator's source root
@@ -542,18 +537,17 @@ module Templater
     
     protected
     
-    def set_argument(n, arg)
-      argument = self.class.arguments[n]
-      valid_argument?(arg, argument[:options], &argument[:block])
-      @arguments[n] = arg
+    def set_argument(n, value)
+      self.class.arguments[n].valid?(value)
+      @arguments[n] = value
     end
     
     def get_argument(n)
-      @arguments[n] || self.class.arguments[n][:options][:default]
+      @arguments[n]
     end
     
-    def set_option(name, arg)
-      @options[name] = arg
+    def set_option(name, value)
+      @options[name] = value
     end
     
     def get_option(name)
@@ -561,30 +555,14 @@ module Templater
     end
     
     def match_options?(options)
-      options.all? { |key, value| self.send(key) == value }
-    end
-        
-    def valid_argument?(arg, options, &block)
-      if arg.nil? and options[:required]
-        raise Templater::TooFewArgumentsError
-      elsif not arg.nil?
-        if options[:as] == :hash and not arg.is_a?(Hash)
-          raise Templater::MalformattedArgumentError, "Expected the argument to be a Hash, but was '#{arg.inspect}'"
-        elsif options[:as] == :array and not arg.is_a?(Array)
-          raise Templater::MalformattedArgumentError, "Expected the argument to be an Array, but was '#{arg.inspect}'"
-        end
-           
-        invalid = catch :invalid do
-          yield if block_given?
-          throw :invalid, :not_invalid
-        end
-        raise Templater::ArgumentError, invalid unless invalid == :not_invalid
+      options.all? do |key, value|
+        key.to_sym.in?(Templater::ACTION_RESERVED_OPTIONS) or self.send(key) == value
       end
     end
-    
+        
     def valid_arguments?
       self.class.arguments.each_with_index do |arg, i|
-        valid_argument?(@arguments[i], arg[:options], &arg[:block])
+        arg.valid?(@arguments[i])
       end
     end
 
@@ -597,7 +575,7 @@ module Templater
       
         # When one of the arguments has :as set to :hash or :list, the remaining arguments should be consumed
         # and converted to a Hash or an Array respectively
-        case expected[:options][:as]
+        case expected.options[:as]
         when :hash
           if arg.is_a?(String)
             pairs = args[i..-1]