cog 0.0.20 → 0.1.0

data/bin/cog

@@ -11,58 +11,72 @@ include GLI::App
 program_desc 'This is a utility to help you write code generators.'
 
 # version Cog::VERSION
+
 desc 'Output more detailed information when running a command'
-switch :v
+switch [:verbose, :v]
+
+desc 'Set the Cogfile explicitly'
+arg_name 'path'
+flag :cogfile
+
+desc 'Set the active tool'
+arg_name 'name'
+default_value 'basic'
+flag :tool
 
 desc 'Add cog to the project in the present working directory'
-skips_pre
 command :init do |c|
 
-  c.action do |global_options, options, args|
+  c.action do |gopt, opt, args|
     Cog.initialize_project
   end
 end
 
-desc 'List or create generators for the current project'
+desc 'Manage project generators'
 command [:generator, :gen] do |c|
   
   c.default_command :list
   
-  c.desc 'List generators for the current project'
+  c.desc 'List project generators'
   c.command :list do |sub|
-    sub.action do |global_options, option, args|
-      x = Cog::Generator.list global_options[:v]
+    sub.action do |gopt, opt, args|
+      x = Cog::Controllers::GeneratorController.list :verbose => gopt[:v]
       puts x.join "\n" unless x.empty?
     end
   end
   
-  c.desc 'Create a new generator for the current project'
-  c.arg_name 'generator_name'
+  c.desc 'Create a new project generator'
+  c.arg_name 'name'
   c.command :new do |sub|
-
-    sub.desc 'which tool to use to create the generator'
-    sub.arg_name 'tool_name'
-    sub.default_value 'basic'
-    sub.flag :tool
-
-    sub.action do |global_options, options, args|
+    sub.action do |gopt, opt, args|
+      args.each do |name|
+        Cog::Controllers::GeneratorController.create name
+      end
+    end
+  end
+  
+  c.desc 'Run project generators'
+  c.long_desc 'Omit generator name to run all of them'
+  c.arg_name 'name'
+  c.command :run do |sub|
+    sub.action do |gopt, opt, args|
+      args = Cog::Controllers::GeneratorController.list if args.empty?
       args.each do |name|
-        Cog::Generator.create name, :tool => options[:tool], :verbose => global_options[:v]
+        Cog::Controllers::GeneratorController.run name
       end
     end
   end
 end
 
 desc 'List or create DSLs known as cog tools'
-skips_pre
 command :tool do |c|
   
   c.default_command :list
   
   c.desc 'List the available tools'
   c.command :list do |sub|
-    sub.action do |global_options, options, args|
-      x = Cog::Tool.list global_options[:v]
+    sub.action do |gopt, opt, args|
+      x = Cog::Controllers::ToolController.list :verbose => gopt[:verbose]
       puts x.join "\n" unless x.empty?
     end
   end
@@ -70,46 +84,38 @@ command :tool do |c|
   c.desc 'Create a new tool'
   c.arg_name 'tool_name'
   c.command :new do |sub|
-    sub.action do |global_options, options, args|
+    sub.action do |gopt, opt, args|
       args.each do |name|
-        Cog::Tool.create name
+        Cog::Controllers::ToolController.create name
       end
     end
   end
 end
 
-desc 'Run generators in the current project'
-arg_name 'generator_name'
-command :run do |c|
+desc 'Manage templates'
+command :template do |c|
   
-  c.action do |global_options, options, args|
-    args = Cog::Generator.list if args.empty?
-    args.each do |name|
-      Cog::Generator.run name, :verbose => global_options[:v]
+  c.default_command :list
+  
+  c.desc 'List the available templates'
+  c.command :list do |sub|
+    sub.action do |gopt, opt, args|
+      x = Cog::Controllers::TemplateController.list :verbose => gopt[:verbose]
+      puts x.join "\n" unless x.empty?
     end
   end
 end
 
-desc 'List supported languages'
-skips_pre
-command :languages do |c|
-
-  c.action do
-    puts 'c++'
-  end
-end
-
-pre do |global_options, command, options, args|
-  # Pre logic here
-  # Return true to proceed; false to abort and not call the
-  # chosen command
-  # Use skips_pre before a command to skip this block
-  # on that command only
-  unless Cog::Config.instance.project?
-    STDERR.write "No Cogfile could be found\n".color(:red)
-    STDOUT.write "Run `cog init` to prepare a project for use with cog\n"
+pre do |gopt, command, opt, args|
+  if gopt[:cogfile] && !File.exists?(gopt[:cogfile])
+    STDERR.write "No such Cogfile at #{gopt[:cogfile]}\n"
     false
   else
+    Cog::Config.instance = Cog::Config.new gopt[:cogfile] if gopt[:cogfile]
+    unless command.name == :init
+      Cog::Config.instance.register_tools
+      Cog::Config.instance.activate_tool gopt[:tool]
+    end
     true
   end
 end
@@ -126,9 +132,4 @@ on_error do |exception|
   true
 end
 
-begin
-  exit run(ARGV)
-rescue
-  # Don't show stack traces during normal use
-  raise unless ENV['COG_DEBUG'].nil? || /^(|0|false|no|off)$/i =~ ENV['COG_DEBUG']
-end
+exit run(ARGV)

data/lib/cog.rb

@@ -1,8 +1,9 @@
 require 'cog/config'
+require 'cog/controllers'
+require 'cog/errors'
 require 'cog/generator'
-require 'cog/tool'
+require 'cog/helpers'
 require 'cog/version'
-require 'fileutils'
 
 # +cog+ is a command line utility that makes it a bit easier to organize a project
 # which uses code generation. These are the API docs, but you might want to read
@@ -21,5 +22,5 @@ module Cog
       nil
     end
   end
-  
+
 end

data/lib/cog/built_in_tools/basic.rb

@@ -0,0 +1,10 @@
+module Cog
+  module Tools
+
+    # The default +cog+ tool.
+    # Creates generator/template pairs.
+    module BasicTool
+    end
+    
+  end
+end

data/lib/cog/built_in_tools/basic/cog_tool.rb

@@ -0,0 +1,15 @@
+require 'cog'
+
+# Register basic as a tool with cog
+Cog::Config.instance.register_tool __FILE__, :built_in => true do |tool|
+
+  # Define how new baisc generators are created
+  #
+  # When the block is executed, +self+ will be an instance of Cog::Config::Tool::GeneratorStamper
+  tool.stamp_generator do
+    template_dest = File.join config.project_templates_path, "#{name}.txt.erb"
+    stamp 'basic/generator.rb', generator_dest, :absolute_destination => true
+    stamp 'basic/template.txt.erb', template_dest, :absolute_destination => true
+  end
+  
+end

data/lib/cog/config.rb

@@ -1,5 +1,6 @@
 require 'cog/config/cogfile'
-require 'singleton'
+require 'cog/config/tool'
+require 'cog/errors'
 
 module Cog
   
@@ -27,28 +28,87 @@ module Cog
     # @return [String] directory in which to find custom project templates
     attr_reader :project_templates_path
     
-    # @return [Boolean] are we operating in the context of a project?
+    # @return [Tool] the active tool affects the creation of new generators
+    attr_reader :active_tool
+    
+    # @return [Boolean] whether or not we operating in the context of a project
     def project?
       !@project_root.nil?
     end
-
-    # @param value [String] a value which is set by the active tool
-    attr_writer :tool_templates_path
-    
-    # @return [String] a value which is set by the active tool
-    attr_accessor :tool_generator_template
     
     # A list of directories in which to find ERB template files
     #
     # Templates should be looked for in the following order as determined by the list returned from this method
     #
-    # * {#project_templates_path}, present if we are in the context of a {#project?}
-    # * tool templates, present if we are in the context of a tool (i.e. a tool has set {#tool_templates_path=})
-    # * +cog+ built-in templates, always present
+    # * {#project_templates_path} which is present if {#project?}
+    # * {Tool#templates_path} for each registered tool (in no particular order)
+    # * {Config.cog_templates_path} which is *always* present
     #
     # @return [Array<String>] a list of directories order with ascending priority
     def template_paths
-      [@project_templates_path, @tool_templates_path, File.join(Config.gem_dir, 'templates')].compact
+      paths = [@project_templates_path]
+      paths += tools.collect {|tool| tool.templates_path}
+      paths << Config.cog_templates_path
+      paths.compact
+    end
+    
+    # @return [Array<Tool>] a sorted list of available tools
+    def tools
+      @tools.values.sort
+    end
+    
+    # Register built-in and custom tools.
+    # @api developer
+    #
+    # Custom tools are specified in the +COG_TOOLS+ environment variable.
+    # @return [nil]
+    def register_tools
+      # Register built-in tools
+      [:basic].each do |built_in|
+        require File.join(Config.gem_dir, 'lib', 'cog', 'built_in_tools', built_in.to_s, 'cog_tool.rb')
+      end
+      # Register custom tools defined in COG_TOOLS
+      (ENV['COG_TOOLS'] || '').split(':').each do |path|
+        explicit = path.end_with? '.rb'
+        @next_tool_was_required_explicitly = explicit
+        path = "#{path}/cog_tool" unless explicit
+        begin
+          require path
+        rescue LoadError
+          raise Errors::CouldNotLoadTool.new path
+        end
+      end
+      nil
+    end
+
+    # Define a new +cog+ tool
+    # @api developer
+    # @param path [String] path to the <tt>cog_tool.rb</tt> file
+    # @option opt [Boolean] :built_in (false) if +true+, then treat this tool as a built-in tool
+    # @yield [Tool] define the tool
+    # @return [nil]
+    def register_tool(path, opt={}, &block)
+      tool = Tool.new path, :built_in => opt[:built_in], :explicit_require => @next_tool_was_required_explicitly
+      block.call tool
+      @tools[tool.name] = tool
+      nil
+    end
+    
+    # @api developer
+    # @return [Boolean] whether or not a tool is registered with the given name
+    def tool_registered?(name)
+      @tools.member? name
+    end
+    
+    # Activate the registered tool with the given name
+    # @api developer
+    # @param name [String] name of the registered tool to activate
+    # @return [nil]
+    def activate_tool(name)
+      throw :ToolAlreadyActivated unless @active_tool.nil?
+      raise Errors::NoSuchTool.new(name) unless tool_registered?(name)
+      @tools[name].load
+      @active_tool = @tools[name]
     end
     
     # Location of the installed cog gem
@@ -64,20 +124,38 @@ module Cog
       end
     end
     
-    # The singleton instance
+    # Location of the built-in templates
+    def self.cog_templates_path
+      File.join Config.gem_dir, 'templates'
+    end
+
+    # @param cogfile_path [String] if provided the {Cogfile} at the given path
+    #   is used to initialize this instance, and {#project?} will be +true+
+    def initialize(cogfile_path = nil)
+      @project_root = nil
+      @tools = {}
+      @language = 'c++'
+      if cogfile_path
+        @cogfile_path = File.expand_path cogfile_path
+        @project_root = File.dirname @cogfile_path
+        cogfile = Cogfile.new self
+        cogfile.interpret
+      end
+    end
+
+    # Find or create the singleton {Config} instance.
     #
-    # Initialized using the Cogfile for the current project, if any can be
-    # found. If not, then {#project?} will be +false+ and all the +project_...+
-    # attributes will be +nil+.
+    # Initialized using the {Cogfile} for the current project, if any can be
+    # found. If not, {#project?} will be +false+ and all the <tt>project_...</tt>
+    # methods will return +nil+.
     #
-    # The Cogfile will be looked for in the present working directory. If none
+    # The {Cogfile} will be looked for in the present working directory. If none
     # is found there the parent directory will be checked, and then the
     # grandparent, and so on.
     # 
-    # @return [Config] the singleton Config instance
+    # @return [Config] the singleton instance
     def self.instance
       return @instance if @instance
-      @instance = self.new
       
       # Attempt to find a Cogfile
       parts = Dir.pwd.split File::SEPARATOR
@@ -86,23 +164,23 @@ module Cog
         i -= 1
       end
       path = File.join(parts.slice(0, i) + ['Cogfile']) if i >= 0
+      
       if path && File.exists?(path)
-        @instance.instance_eval do
-          @cogfile_path = File.expand_path path
-          @project_root = File.dirname @cogfile_path
-          cogfile = Cogfile.new self
-          cogfile.interpret
-        end
+        @instance = self.new path
+      else
+        @instance = self.new
       end
-      
-      @instance
     end
-
-  private
-
-    def initialize
-      @project_root = nil
-      @language = 'c++'
+    
+    # Explicitly set the singleton Config instance.
+    #
+    # The singleton must not already be set.
+    #
+    # @param config [Config] the instance to set as the singleton
+    # @return [nil]
+    def self.instance=(config)
+      throw :ConfigInstanceAlreadySet unless @instance.nil?
+      @instance = config
     end
 
   end

data/lib/cog/config/tool.rb

@@ -0,0 +1,99 @@
+require 'cog/errors'
+require 'cog/generator'
+
+module Cog
+  class Config
+
+    class Tool
+      
+      # @return [String] name of the tool
+      attr_reader :name
+
+      # @return [String] explicit path to the tool
+      attr_reader :path
+      
+      # @return [String] directory in which to find tool templates
+      attr_reader :templates_path
+      
+      # @return [Boolean] the tool needs to be explicitly required
+      attr_reader :explicit_require
+      
+      # @param path [String] path to the <tt>cog_tool.rb</tt> file
+      # @option opt [Boolean] :built_in (false) if +true+, {#templates_path} will be +nil+ for this tool, as the templates should be included with +cog+
+      # @option opt [Boolean] :explicit_require (false) the tool needs to be explicitly required
+      def initialize(path, opt={})
+        unless File.basename(path) == 'cog_tool.rb' && File.exists?(path)
+          raise Errors::InvalidToolConfiguration.new(path)
+        end
+        dir = File.dirname(path)
+        @name = File.basename dir
+        @path = File.expand_path File.join(dir, '..', "#{@name}.rb")
+        @explicit_require = opt[:explicit_require]
+        unless opt[:built_in]
+          @templates_path = File.expand_path File.join(dir, '..', '..', 'cog', 'templates')
+        end
+      end
+      
+      # Fully load the tool
+      def load
+        require @path
+      end
+
+      # Encapsulates the block which stamps the generator for this tool
+      class GeneratorStamper
+        
+        include Generator
+        
+        # @return [Config] singleton instance
+        attr_accessor :config
+        
+        # @return [String] path to the generator file which should be created
+        attr_reader :generator_dest
+        
+        # @return [String] +underscore_version+ of the generator name
+        attr_reader :name
+        
+        # @return [Tool] the tool for which this stamps generators
+        attr_reader :tool
+        
+        # @return [String] +CamelizedVersion+ of the generator name
+        def camelized
+          @name.camelize
+        end
+        
+        # @api developer
+        # @param tool [Tool]
+        # @param block [Block]
+        def initialize(tool, block)
+          @tool = tool
+          @block = block
+        end
+        
+        # Stamp the generator
+        # @api developer
+        def stamp_generator(name, generator_dest, config)
+          @name = name.to_s.underscore
+          @config = config
+          @generator_dest = generator_dest
+          instance_eval &@block
+        end
+      end
+      
+      # @api developer
+      # @return [GeneratorStamper] 
+      attr_reader :generator_stamper
+
+      # Define a block to call when stamping a generator for this tool
+      #
+      # @yield The block should do the work of stamping the generator file, and any custom templates. The block's +self+ object will be a {GeneratorStamper}
+      def stamp_generator(&block)
+        @generator_stamper = GeneratorStamper.new self, block
+      end
+      
+      # Sort tools by name
+      def <=>(other)
+        @name <=> other.name
+      end
+    end
+  end
+end