cog 0.2.1 → 0.2.2

data/bin/cog

@@ -60,7 +60,7 @@ command [:generator, :gen] do |c|
       args.each do |name|
         if opt[:language] && opt[:language] != 'in Cogfile'
           lang = Cog::Languages.get_language opt[:language]
-          Cog::Config.instance.target_language = lang
+          Cog.target_language = lang
         end
         Cog::Controllers::GeneratorController.create name
       end
@@ -72,7 +72,7 @@ command [:generator, :gen] do |c|
   c.arg_name 'name'
   c.command :run do |sub|
     sub.action do |gopt, opt, args|
-      raise Cog::Errors::ActionRequiresProject.new('run generator') unless Cog::Config.instance.project?
+      raise Cog::Errors::ActionRequiresProject.new('run generator') unless Cog.project?
       Cog::Embeds.gather_from_project
       args = Cog::Controllers::GeneratorController.list if args.empty?
       args.each do |name|
@@ -145,7 +145,7 @@ command [:language, :lang] do |c|
   c.desc 'List the supported languages'
   c.command :list do |sub|
     sub.action do
-      summary = Cog::Config.instance.language_summary
+      summary = Cog.language_summary
       w = summary.collect {|info| info.name.length}.max
       summary.each do |info|
         puts info.to_s(w)
@@ -161,10 +161,10 @@ pre do |gopt, command, opt, args|
     STDERR.write "No such Cogfile at #{gopt[:cogfile]}\n"
     false
   else
-    Cog::Config.instance = Cog::Config.new gopt[:cogfile] if gopt[:cogfile]
+    Cog.prepare :cogfile_path => gopt[:cogfile]
     unless command.name == :init
-      Cog::Config.instance.register_tools
-      Cog::Config.instance.activate_tool gopt[:tool]
+      Cog.register_tools
+      Cog.activate_tool gopt[:tool]
     end
     true
   end

data/lib/cog.rb

@@ -5,24 +5,20 @@ require 'cog/errors'
 require 'cog/generator'
 require 'cog/helpers'
 require 'cog/languages'
+require 'cog/tool'
 require 'cog/version'
 
-# +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
-# the {https://github.com/ktonon/cog#readme general introduction} first.
+# This top level module serves as a singleton instance of the {Config} interface.
 module Cog
 
+  extend Config
+  
   # Prepare the project in the present working directory for use with +cog+
   # @return [nil]
   def self.initialize_project
-    Object.new.instance_eval do
-      class << self ; include Generator ; end
-      copy_file_if_missing File.join(Config.gem_dir, 'Default.cogfile'), 'Cogfile'
-      config = Config.instance
-      touch_directory config.project_generators_path
-      touch_directory config.project_templates_path
-      nil
-    end
+    Generator.copy_file_if_missing File.join(Cog.gem_dir, 'Default.cogfile'), 'Cogfile'
+    Cog.prepare :force_reset => true
+    nil
   end
 
 end

data/lib/cog/built_in_tools/basic.rb

@@ -2,7 +2,7 @@ module Cog
   module BuiltInTools
 
     # The default +cog+ tool.
-    # Creates generator/template pairs.
+    # Creates an example generator.
     module Basic
     end
     

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

@@ -1,18 +1,11 @@
 require 'cog'
+include Cog::Generator
 
-# Register basic as a tool with cog
-Cog::Config.instance.register_tool __FILE__, :built_in => true do |tool|
+Cog.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
-    @language = Cog::Config.instance.target_language
-    stamp 'basic/generator.rb', generator_dest, :absolute_destination => true
-    @language.module_extensions.each do |ext|
-      template_dest = File.join config.project_templates_path, "#{name}.#{ext}.erb"
-      stamp "basic/template.#{ext}.erb", template_dest, :absolute_destination => true
-    end
+  tool.stamp_generator do |name, dest|
+    @name = name
+    stamp 'basic/generator.rb', dest, :absolute_destination => true
   end
   
 end

data/lib/cog/config.rb

@@ -1,173 +1,27 @@
 require 'cog/config/cogfile'
-require 'cog/config/tool'
-require 'cog/config/lang_info'
+require 'cog/config/language_methods'
+require 'cog/config/project_methods'
+require 'cog/config/tool_methods'
 require 'cog/languages'
 require 'cog/errors'
+require 'cog/tool'
 
 module Cog
   
-  # This is a low level interface. It is mainly used by the {Generator} methods
-  # to determine where to find things, and where to put them. When +cog+ is used
-  # in a project the values of the singleton {Config.instance} should be configured using
-  # a {Cogfile}.
-  class Config
-        
-    # @return [String] path to the project's {Cogfile}
-    attr_reader :cogfile_path
+  # This is a low level interface. It is mainly used by the {Generator} methods to determine where to find things, and where to put them.
+  # When +cog+ is used in a project it will be configured with a {Cogfile}. The Cogfile is processed during a call to {#prepare}.
+  module Config
+    include ProjectMethods
+    include LanguageMethods
+    include ToolMethods
 
-    # @return [String] directory in which to find project generators
-    attr_reader :project_generators_path
-
-    # @return [String] directory in which the project's {Cogfile} is found
-    attr_reader :project_root
-    
-    # @return [String] directory to which project source code is generated
-    attr_reader :project_source_path
-
-    # @return [String] directory in which to find custom project templates
-    attr_reader :project_templates_path
-    
-    # @return [Languages::Lanugage] target language which should be used when creating generators, and no language is explicitly specified
-    attr_accessor :target_language
-    
-    # @return [Languages::Language] language which is active in the current context
-    def active_language
-      @active_languages.last
-    end
-    
-    # @return [Tool] the active tool affects the creation of new generators
-    def active_tool
-      @active_tools.last
-    end
-    
-    # @return [Boolean] whether or not we operating in the context of a project
-    def project?
-      !@project_root.nil?
-    end
-    
-    # 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} 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, active_tool && active_tool.templates_path, Config.cog_templates_path].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
+    # @return [String] Location of the built-in templates
+    def cog_templates_path
+      File.join Cog.gem_dir, 'templates'
     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 with the scope of the provided block.
-    # If no block is provided, the tool will remain active indefinitely.
-    # @param name [String] name of the registered tool to activate
-    # @yield the tool will be active within this block
-    # @return [nil]
-    def activate_tool(name, &block)
-      name = name.to_s
-      raise Errors::NoSuchTool.new(name) unless tool_registered?(name)
-      @tools[name].load
-      @active_tools << @tools[name]
-      if block
-        block.call
-        @active_tools.pop
-      end
-    end
-    
-    # Activate a given language within the scope of the provided block.
-    # Either provide <tt>:id</tt> or <tt>:ext</tt> but not both. If the extension does not match any of the supported languages, the {#active_language} will not change, but the block will still be called.
-    # @option opt [:String] :id (nil) the lanuage identifier. Type <tt>cog language list</tt> to see the possible values
-    # @option opt [:String] :ext (nil) a file extension which will map to a language identifier. Type <tt>cog language map</tt> to see mapped extensions
-    # @yield within this block the {#active_language} will be set to the desired value
-    # @return [Object] the value returned by the block
-    def activate_language(opt={}, &block)
-      lang_id = if opt[:ext]
-        ext = opt[:ext].to_s
-        ext = ext.slice(1..-1) if ext.start_with?('.')
-        @language_extension_map[ext.downcase.to_sym] unless ext.empty?
-      else
-        opt[:id]
-      end
-      if lang_id
-        @active_languages << Languages.get_language(lang_id)
-        r = block.call
-        @active_languages.pop
-        r
-      else
-        block.call
-      end
-    end
-    
-    # @param ext [String] the file extension
-    # @return [Languages::Language, nil] the language for the given extension
-    def language_for_extension(ext)
-      ext = ext.to_s.downcase.to_sym
-      lang_id = @language_extension_map[ext]
-      Languages.get_language lang_id unless lang_id.nil?
-    end
-    
-    # @return [Array<LangInfo>] current configuration of supported languages
-    def language_summary
-      summary = {}
-      @language_extension_map.each_pair do |ext, lang_id|
-        lang_id = Languages::ALIAS[lang_id] || lang_id
-        summary[lang_id] ||= LangInfo.new(lang_id, Languages::REV_ALIAS[lang_id] || [])
-        summary[lang_id].extensions << ext
-      end
-      summary.values.sort
-    end
-    
-    # Location of the installed cog gem
-    # @return [String] path to the cog gem
-    def self.gem_dir
+    # @return [String] Location of the installed cog gem
+    def gem_dir
       spec = Gem.loaded_specs['cog']
       if spec.nil?
         # The current __FILE__ is:
@@ -178,67 +32,60 @@ module Cog
       end
     end
     
-    # 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)
+    # 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} which is present if {#project?}
+    # * {Tool#templates_path} for each registered tool (in no particular order)
+    # * {#cog_templates_path} which is *always* present
+    #
+    # @return [Array<String>] a list of directories order with ascending priority
+    def template_paths
+      [@project_templates_path, active_tool && active_tool.templates_path, Cog.cog_templates_path].compact
+    end
+ 
+    # Must be called once before using cog.
+    # In the context of a command-line invocation, this method will be called automatically. Outside of that context, for example in a unit test, it will have to be called manually.
+    # @option opt [String] :cogfile_path (nil) explicitly specify the location of the project {Cogfile}. If not provided, it will be searched for. If none can be found, {#project?} will be +false+
+    # @option opt [Boolean] :force_reset (false) unless this is +true+, calling prepare a second time will fail
+    def prepare(opt={})
+      throw :ConfigInstanceAlreadyPrepared if @prepared && !opt[:force_reset]
+      @prepared = true
+      @cogfile_path = nil
       @project_root = nil
+      @project_generators_path = nil
+      @project_templates_path = nil
+      @project_source_path = nil
       @tools = {}
       @active_tools = [] # active tool stack
       @target_language = Languages::Language.new
       @active_languages = [Languages::Language.new] # active language stack
       @language_extension_map = Languages::DEFAULT_LANGUAGE_EXTENSION_MAP
-      if cogfile_path
-        @cogfile_path = File.expand_path cogfile_path
+      opt[:cogfile_path] ||= find_default_cogfile
+      if opt[:cogfile_path]
+        @cogfile_path = File.expand_path opt[: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, {#project?} will be +false+ and all the <tt>project_...</tt>
-    # methods will return +nil+.
-    #
+    
+    private
+    
     # 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 instance
-    def self.instance
-      return @instance if @instance
-      
-      # Attempt to find a Cogfile
+    def find_default_cogfile
       parts = Dir.pwd.split File::SEPARATOR
       i = parts.length
       while i >= 0 && !File.exists?(File.join(parts.slice(0, i) + ['Cogfile']))
         i -= 1
       end
       path = File.join(parts.slice(0, i) + ['Cogfile']) if i >= 0
-      
-      if path && File.exists?(path)
-        @instance = self.new path
-      else
-        @instance = self.new
-      end
-    end
-    
-    # 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
+      (path && File.exists?(path)) ? path : nil
     end
-
   end
 end

data/lib/cog/config/cogfile.rb

@@ -2,12 +2,10 @@ require 'active_support/core_ext'
 require 'cog/languages'
 
 module Cog
-  class Config
+  module Config
     
     # In your project's +Cogfile+, +self+ has been set to an instance of this class.
-    #
     # Typing <tt>cog init</tt> will create a +Cogfile+ in the present working directory.
-    # +Cogfile+ files are used to configure an instance of {Config}.
     #
     # @example
     #   # All paths are relative to the directory containing this file.
@@ -45,7 +43,7 @@ module Cog
         @config = config
       end
     
-      # Interpret the +Cogfile+ at {Config#cogfile_path}
+      # Interpret the +Cogfile+ at {Config::ProjectMethods#cogfile_path}
       # @api developer
       # @return [nil]
       def interpret
@@ -57,7 +55,7 @@ module Cog
     
       # Define the directory in which to find project generators
       # @param path [String] a file system path
-      # @param absolute [Boolean] if +false+, the path is relative to {Config#project_root}
+      # @param absolute [Boolean] if +false+, the path is relative to {Config::ProjectMethods#project_root}
       # @return [nil]
       def project_generators_path(path, absolute=false)
         @config.instance_eval do
@@ -68,7 +66,7 @@ module Cog
 
       # Define the directory in which to find custom project templates
       # @param path [String] a file system path
-      # @param absolute [Boolean] if +false+, the path is relative to {Config#project_root}
+      # @param absolute [Boolean] if +false+, the path is relative to {Config::ProjectMethods#project_root}
       # @return [nil]
       def project_templates_path(path, absolute=false)
         @config.instance_eval do
@@ -79,7 +77,7 @@ module Cog
 
       # Define the directory to which project source code is generated
       # @param path [String] a file system path
-      # @param absolute [Boolean] if +false+, the path is relative to {Config#project_root}
+      # @param absolute [Boolean] if +false+, the path is relative to {Config::ProjectMethods#project_root}
       # @return [nil]
       def project_source_path(path, absolute=false)
         @config.instance_eval do

data/lib/cog/config/lang_info.rb

@@ -1,5 +1,5 @@
 module Cog
-  class Config
+  module Config
     
     # Describes configuration of a supported language
     class LangInfo