cog 0.2.2 → 0.3.0

data/lib/cog/config/{language_methods.rb → language_config.rb}

@@ -1,36 +1,32 @@
-require 'cog/config/lang_info'
-
 module Cog
   module Config
     
     # {Config} methods related to languages
-    module LanguageMethods
-      
-      # @return [Languages::Lanugage] target language which should be used when creating generators, and no language is explicitly specified
-      attr_accessor :target_language
+    module LanguageConfig
       
-      # @return [Languages::Language] language which is active in the current context
+      # @return [Language] language which is active in the current context
       def active_language
         @active_languages.last
       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
+      # Either provide <tt>key</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.
+      # @param key [:String] 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)
+      def activate_language(key, opt={}, &block)
         throw :ActivateLanguageRequiresABlock if block.nil?
-        lang_id = if opt[:ext]
-          ext = opt[:ext].to_s
+        opt, key = key, nil if key.is_a? Hash
+        key = if opt[:ext]
+          ext = opt[:ext].to_s.downcase
           ext = ext.slice(1..-1) if ext.start_with?('.')
-          @language_extension_map[ext.downcase.to_sym] unless ext.empty?
+          @language_extension_map[ext] unless ext.empty?
         else
-          opt[:id]
+          key
         end
-        if lang_id
-          @active_languages << Languages.get_language(lang_id)
+        if key
+          @active_languages << @language[key]
           r = block.call
           @active_languages.pop
           r
@@ -44,26 +40,26 @@ module Cog
         @language_extension_map.keys
       end
 
+      # @param key [String] the language key
+      # @return [Language] the language for the given key
+      def language(key)
+        @language[key]
+      end
+      
       # @param path [String] the file system extension, or full path to a file
-      # @return [Languages::Language, nil] the language for the given extension
+      # @return [Language, nil] the language for the given extension
       def language_for(path)
         ext = File.extname(path.to_s)
         ext = path.to_s if ext.empty?
         ext = ext.downcase
         ext = ext.slice(1..-1) if ext.start_with? '.'
-        lang_id = @language_extension_map[ext.to_sym]
-        Languages.get_language lang_id unless lang_id.nil?
+        key = @language_extension_map[ext]
+        @language[key] if key
       end
 
-      # @return [Array<LangInfo>] current configuration of supported languages
+      # @return [Array<Language>] 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
+        @language.values.sort
       end
     
     end

data/lib/cog/config/plugin_config.rb

@@ -0,0 +1,31 @@
+module Cog
+  module Config
+    
+    # {Config} methods related to plugins
+    module PluginConfig
+      
+      # @return [Plugin] the plugin registered for the given name
+      def plugin(name)
+        @plugins[name]
+      end
+    
+      # @return [Array<Plugin>] a sorted list of available plugins
+      def plugins
+        @plugins.values.sort
+      end
+    
+      # @api developer
+      # Register plugins found in the given directory
+      # @param path [String] path to a directory containing cog plugins
+      # @return [nil]
+      def register_plugins(path)
+        Dir.glob("#{path}/*/Cogfile").each do |cogfile_path|
+          p = Plugin.new cogfile_path
+          @plugins[p.name] ||= p
+        end
+        nil
+      end
+
+    end
+  end
+end

data/lib/cog/config/project_config.rb

@@ -0,0 +1,48 @@
+module Cog
+  module Config
+
+    # {Config} methods related to projects
+    module ProjectConfig
+      
+      # @return [String] path to the project's {DSL::Cogfile}
+      attr_reader :project_cogfile_path
+
+      # @return [String] directory in which to place generated output. For example, the +destination+ parameter of {Generator#stamp} is relative to this path.
+      attr_reader :project_path
+
+      # @return [String] directory in which the project's {DSL::Cogfile} is found
+      attr_reader :project_root
+    
+      # @return [String,nil] directory in which to place project generators
+      attr_reader :project_generator_path
+
+      # @return [String,nil] directory in which to place project plugins
+      attr_reader :project_plugin_path
+
+      # @return [String,nil] directory in which to place project templates
+      attr_reader :project_template_path
+      
+      # @return [Boolean] whether or not we operating in the context of a project
+      def project?
+        !@project_root.nil?
+      end
+
+      # @return [Array<String>] list of paths to files in the {#project_path} which are written in a supported language
+      def supported_project_files
+        if project?
+          exts = Cog.language_extensions.join ','
+          Dir.glob "#{Cog.project_path}/**/*.{#{exts}}"
+        else
+          []
+        end
+      end
+      
+      private
+      
+      def path_if_for_project(path)
+        path if path && path.start_with?(@project_root)
+      end
+      
+    end
+  end
+end

data/lib/cog/controllers.rb

@@ -1,13 +1,11 @@
-require 'cog/controllers/generator_controller'
-require 'cog/controllers/template_controller'
-require 'cog/controllers/tool_controller'
-require 'cog/errors'
-
 module Cog
 
-  # Contains controllers for managing basic +cog+ objects like generators, templates, and tools
+  # Contains controllers for managing basic +cog+ objects like generators, templates, and plugins
   module Controllers
-  end
+    
+    autoload :GeneratorController, 'cog/controllers/generator_controller'
+    autoload :TemplateController, 'cog/controllers/template_controller'
+    autoload :PluginController, 'cog/controllers/plugin_controller'
 
+  end
 end
-

data/lib/cog/controllers/generator_controller.rb

@@ -1,8 +1,3 @@
-require 'cog/config'
-require 'cog/errors'
-require 'cog/helpers'
-require 'rainbow'
-
 module Cog
   module Controllers
     
@@ -11,34 +6,48 @@ module Cog
       
       # Create a new generator
       # @param name [String] the name to use for the new generator
+      # @option opt [String] :plugin_name (nil) plugin to use
       # @return [Boolean] was the generator successfully created?
-      def self.create(name)
-        raise Errors::ActionRequiresProject.new('create generator') unless Cog.project?
-        generator_dest = File.join Cog.project_generators_path, "#{name}.rb"
-        raise Errors::DuplicateGenerator.new(generator_dest) if File.exists?(generator_dest)
-        Cog.active_tool.stamp_generator name, generator_dest
+      def self.create(name, opt={})
+        plugin = Cog.plugin(opt[:plugin_name])
+        prefix = Cog.project_generator_path
+        raise Errors::NoSuchPlugin.new(opt[:plugin_name]) if plugin.nil?
+        raise Errors::PluginMissingDefinition.new('stamp_generator') if plugin.stamp_generator_block.nil?
+        raise Errors::ActionRequiresProjectGeneratorPath.new('create generator') unless prefix
+        dest = File.join prefix, "#{name}.rb"
+        raise Errors::DuplicateGenerator.new(dest) if File.exists?(dest)
+        plugin.stamp_generator_block.call name.to_s, dest
       end
 
       # List the available project generators
-      # @option opt [Boolean] :verbose (false) list full paths to generator files
       # @return [Array<String>] a list of generators
-      def self.list(opt={})
-        raise Errors::ActionRequiresProject.new('list generators') unless Cog.project?
-        x = Dir.glob(File.join Cog.project_generators_path, '*.rb')
-        opt[:verbose] ? x : (x.collect {|path| File.basename(path).slice(0..-4)})
+      def self.list
+        Helpers::CascadingSet.process_paths Cog.generator_path, :ext => 'rb'
       end
 
       # Run the generator with the given name
-      # @param name [String] name of the generator as returned by {GeneratorController.list}
+      # @param name [String] name of the generator to run
       # @return [nil]
       def self.run(name)
-        raise Errors::ActionRequiresProject.new('run generator') unless Cog.project?
-        path = File.join Cog.project_generators_path, "#{name}.rb"
-        raise Errors::NoSuchGenerator.new(name) unless File.exists?(path)
-        require path
-        nil
+        Cog.generator_path.reverse.each do |root|
+          path = File.join root, "#{name}.rb"
+          if File.exists?(path)
+            GeneratorSandbox.new(path).interpret
+            return
+          end
+        end
+        raise Errors::NoSuchGenerator.new(name)
       end
       
+      # Run all generators
+      # @return [nil]
+      def self.run_all
+        Cog.generator_path.each do |root|
+          Dir.glob("#{root}/*.rb").each do |path|
+            GeneratorSandbox.new(path).interpret
+          end
+        end
+      end
     end
   end
 end

data/lib/cog/controllers/plugin_controller.rb

@@ -0,0 +1,43 @@
+module Cog
+  module Controllers
+    
+    # Manage +cog+ plugins
+    #
+    # @see https://github.com/ktonon/cog#plugins Introduction to Plugins
+    module PluginController
+
+      # Generate a new project plugin with the given name
+      # @param name [String] name of the plugin to create. Should not conflict with other plugin names
+      # @return [nil]
+      def self.create(name)
+        raise Errors::DuplicatePlugin.new(name) unless Cog.plugin(name).nil?
+        @cogfile_type = :plugin
+        @prefix = ''
+        @cog_version = Cog::VERSION
+        @plugin_name = name.to_s.underscore
+        @plugin_module = name.to_s.camelize
+        prefix = Cog.project_plugin_path
+        prefix = prefix ? "#{prefix}/" : ''
+        opt = { :absolute_destination => true, :binding => binding }
+        [
+          ['Cogfile', 'Cogfile'],
+          ['plugin/plugin.rb', "lib/#{@plugin_name}.rb"],
+          ['plugin/generator.rb.erb', "templates/#{@plugin_name}/generator.rb.erb"],
+        ].each do |tm, dest|
+          Generator.stamp "cog/#{tm}", "#{prefix}#{@plugin_name}/#{dest}", opt
+        end
+        nil
+      end
+
+      # @return [Array<String>] a list of available plugins
+      def self.list
+        cs = Helpers::CascadingSet.new
+        Cog.plugins.each do |plugin|
+          cs.add_plugin plugin
+        end
+        cs.to_a
+      end
+
+    end
+  end
+end

data/lib/cog/controllers/template_controller.rb

@@ -1,53 +1,32 @@
-require 'cog/config'
-require 'cog/errors'
-require 'cog/generator'
-require 'cog/helpers'
-require 'rainbow'
-
 module Cog
   module Controllers
     
     # Manage a project's templates
     module TemplateController
 
-      # List the available templates
-      # @option opt [Boolean] :verbose (false) list full template paths
-      # @return [Array<String>] a list of templates
-      def self.list(opt={})
-        cts = Helpers::CascadingTemplateSet.new
-        cts.add_templates 'built-in', :built_in, Cog.cog_templates_path, opt
-        tool = Cog.active_tool
-        unless tool.templates_path.nil?
-          cts.add_templates tool.name, :tool, tool.templates_path, opt
-        end
-        if Cog.project?
-          cts.add_templates 'project', :project, Cog.project_templates_path, opt
-        end
-        cts.to_a
-      end
-      
       # Create a new project template
       # @param name [String] name of the template, relative to the project's templates directory
-      # @option opt [Boolean] :force_override (false) if a built-in or tool template with the same name already exists, should a project override be created?
+      # @option opt [Boolean] :force_override (false) if a built-in or plugin template with the same name already exists, should a project override be created?
       # @return [nil]
       def self.create(name, opt={})
-        raise Errors::ActionRequiresProject.new('create template') unless Cog.project?
+        prefix = Cog.project_template_path
+        raise Errors::ActionRequiresProjectTemplatePath.new('create template') unless prefix
         name = name.without_extension :erb
-        dest = File.join Cog.project_templates_path, "#{name}.erb"
-
+        dest = File.join prefix, "#{name}.erb"
         original = Generator.get_template name, :as_path => true
-        return if original == dest # Nothing to create
-        if opt[:force_override]
-          Generator.copy_file_if_missing original, dest
-        else
-          raise Errors::DuplicateTemplate.new original
-        end
+        Generator.copy_file_if_missing original, dest
         nil
       rescue Errors::NoSuchTemplate
         # No original, ok to create an empty template
-        touch_file dest
+        Generator.touch_file dest
         nil
       end
+
+      # List the available templates
+      # @return [Array<String>] a list of templates
+      def self.list
+        Helpers::CascadingSet.process_paths Cog.template_path, :ext => 'erb'
+      end
       
     end
   end

data/lib/cog/dsl.rb

@@ -0,0 +1,9 @@
+module Cog
+  module DSL
+    
+    autoload :Cogfile, 'cog/dsl/cogfile'
+    autoload :LanguageDSL, 'cog/dsl/language_dsl'
+    autoload :PluginDSL, 'cog/dsl/plugin_dsl'
+    
+  end
+end

data/lib/cog/dsl/cogfile.rb

@@ -0,0 +1,145 @@
+module Cog
+  module DSL
+    
+    # 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.
+    class Cogfile
+      
+      include Generator
+      
+      # Initialize with an instance of {Config}
+      # @api developer
+      # @param config [Config] the object which will be configured by this Cogfile
+      # @param path [String] path to the cogfile
+      # @option opt [Boolean] :project (false) is this the project cogfile?
+      # @option opt [Boolean] :plugin_path_only (false) only process +plugin_path+ calls in the given cogfile
+      # @option opt [Plugin] :plugin (nil) indicate that the cogfile is for the given plugin
+      def initialize(config, path, opt={})
+        @cogfile_context = {
+          :config => config,
+          :cogfile_path => path,
+          :cogfile_dir => File.dirname(path),
+          :project => opt[:project],
+          :plugin_path_only => opt[:plugin_path_only],
+          :plugin => opt[:plugin],
+        }
+      end
+    
+      # Interpret the +Cogfile+ at {Config::ProjectConfig#cogfile_path}
+      # @api developer
+      # @return [nil]
+      def interpret
+        eval File.read(cogfile_path), binding
+        nil
+      end
+    
+      # Define the directory in which to generate code
+      # @param path [String] a file system path to a directory
+      # @param absolute [Boolean] if +false+, the path is relative to {Config::ProjectConfig#project_root}
+      # @return [nil]
+      def project_path(path, absolute=false)
+        return if @cogfile_context[:plugin_path_only]
+        path = File.join @cogfile_context[:cogfile_dir], path unless absolute
+        config_eval { @project_path = path }
+      end
+
+      # Define a directory in which to find generators
+      # @param path [String] a file system path
+      # @param absolute [Boolean] if +false+, the path is relative to {Config::ProjectConfig#project_root}
+      # @return [nil]
+      def generator_path(path, absolute=false)
+        return if @cogfile_context[:plugin_path_only]
+        add_config_path :generator, path, absolute
+      end
+
+      # Define a directory in which to find templates
+      # @param path [String] a file system path
+      # @param absolute [Boolean] if +false+, the path is relative to {Config::ProjectConfig#project_root}
+      # @return [nil]
+      def template_path(path, absolute=false)
+        return if @cogfile_context[:plugin_path_only]
+        add_config_path :template, path, absolute
+      end
+      
+      # Define a directory in which to find plugins
+      # @param path [String] a file system path
+      # @param absolute [Boolean] if +false+, the path is relative to {Config::ProjectConfig#project_root}
+      # @return [nil]
+      def plugin_path(path, absolute=false)
+        path = add_config_path :plugin, path, absolute
+        if path && File.exists?(path)
+          raise Errors::PluginPathIsNotADirectory.new path unless File.directory?(path)
+          @cogfile_context[:config].register_plugins path
+        end
+      end
+
+      # Explicitly specify a mapping from file extensions to languages
+      # @param map [Hash] key-value pairs from this mapping will override the default language map supplied by +cog+
+      # @return [nil]
+      def language_extensions(map)
+        return if @cogfile_context[:plugin_path_only]
+        config_eval do
+          map.each_pair do |key, value|
+            @language_extension_map[key.to_s.downcase] = value.to_s.downcase
+          end
+        end
+      end
+      
+      # Define and register a language with cog
+      # @param key [String] unique case-insensitive identifier
+      # @yieldparam lang [LanguageDSL] an interface for defining the language
+      # @return [Object] the return value of the block
+      def language(key, &block)
+        return if @cogfile_context[:plugin_path_only]
+        dsl = LanguageDSL.new key
+        r = block.call dsl
+        lang = dsl.finalize
+        config_eval do
+          @language[lang.key] = lang
+        end
+        r
+      end
+
+      # Register an autoload variable in the class {GeneratorSandbox}. That way when generators are run as instances of a sandbox, they will be able to load plugins just by referencing them using the provided +identifier_name+.
+      # @param identifier_name [String] identifier by which the plugin can be referenced in generators
+      # @param path [String] path to the ruby file to load when the identifier is referenced (relative to the cogfile)
+      # @return [nil]
+      def autoload_plugin(identifier_name, path)
+        GeneratorSandbox.autoload_plugin(identifier_name, File.join(@cogfile_context[:plugin].path, path))
+      end
+      
+      # Define a block to call when stamping a generator for a plugin. A call to this method should only be used in plugin cogfiles.
+      # @yieldparam name [String] name of the generator to stamp
+      # @yieldparam dest [String] file system path where the file will be created
+      # @yieldreturn [nil]
+      # @return [nil]
+      def stamp_generator(&block)
+        @cogfile_context[:plugin].stamp_generator_block = block
+      end
+      
+      private
+      
+      def cogfile_path
+        @cogfile_context[:cogfile_path]
+      end
+
+      # @return [nil]
+      def config_eval(&block)
+        @cogfile_context[:config].instance_eval &block
+        nil
+      end
+      
+      # @return [String,nil] absolute path
+      def add_config_path(name, path, absolute)
+        return if path.nil?
+        path = File.join @cogfile_context[:cogfile_dir], path unless absolute
+        is_project = @cogfile_context[:project]
+        config_eval do
+          instance_variable_set("@project_#{name}_path", path) if is_project
+          instance_variable_get("@#{name}_path") << path
+        end
+        path
+      end
+    end
+  end
+end