cog 0.2.2 → 0.3.0

data/BuiltIn.cogfile

@@ -0,0 +1,96 @@
+generator_path 'built_in/generators'
+template_path 'built_in/templates'
+plugin_path 'built_in/plugins'
+plugin_path Cog.gems_root_dir, true
+
+language :c do |l|
+  l.name 'C'
+  l.comment '//'
+  l.multiline_comment '/*', '*/'
+  l.extension :c, :h
+  l.include_guard_begin {|name| "#ifndef #{name.underscore.upcase}\n#define #{name.underscore.upcase}"}
+  l.include_guard_end {|name| "#endif"}
+end
+
+language 'c++' do |l|
+  l.name 'C++'
+  l.comment_style :c
+  l.include_guard_style :c
+  l.extension :h, :hh, :hpp, :hxx, 'h++', :cc, :cpp, :cxx, 'c++'
+  l.use_named_scope {|name| "using namespace #{name};"}
+  l.named_scope_begin {|name| "namespace #{name} {"}
+  l.named_scope_end {|name| "} // namespace #{name}"}
+end
+
+language 'c#' do |l|
+  l.name 'C#'
+  l.comment_style :c
+  l.extension :cs
+  l.named_scope_begin {|name| "namespace #{name} {"}
+  l.named_scope_end {|name| "} // namespace #{name}"}
+end
+
+language :css do |l|
+  l.name 'Cascading Style Sheets'
+  l.multiline_comment '/*', '*/'
+  l.extension :css
+end
+
+language :html do |l|
+  l.name 'Hyper-text Markup Language'
+  l.comment_style :xml
+  l.extension :html
+  l.named_scope_begin {|name| "<div id='#{name}' class='cog-named-scope'>"}
+  l.named_scope_end {|name| "</div><!-- end of named scope #{name} -->"}
+end
+
+language :java do |l|
+  l.name 'Java'
+  l.comment_style :c
+  l.extension :java
+  l.named_scope_begin {|name| "package #{name};"}
+  l.named_scope_end {|name| "// end of package #{name}"}
+end
+
+language :javascript do |l|
+  l.name 'JavaScript'
+  l.comment_style :c
+  l.extension :js
+  l.named_scope_begin {|name| "var #{name} = { // named scope"}
+  l.named_scope_end {|name| "}; // end of named scope #{name}"}
+end
+
+language :objc do |l|
+  l.name 'Objective-C'
+  l.comment_style :c
+  l.extension :h, :m, :mm
+end
+
+language :python do |l|
+  l.name 'Python'
+  l.comment '#'
+  l.multiline_comment "'''", "'''"
+  l.extension :py
+end
+
+language :qt do |l|
+  l.name 'Qt Project'
+  l.comment '#'
+  l.extension :pro, :pri
+end
+
+language :ruby do |l|
+  l.comment '#'
+  l.multiline_comment '=begin', '=end'
+  l.extension :rb
+  l.named_scope_begin {|name| "module #{name} # named scope"}
+  l.named_scope_end {|name| "end # named scope #{name}"}
+end
+
+language :xml do |l|
+  l.name 'Extensible Markup Language'
+  l.multiline_comment '<!--', '-->'
+  l.extension :xml
+  l.named_scope_begin {|name| "<cog:named-scope id='#{name}'>"}
+  l.named_scope_end {|name| "</cog:named-scope><!-- #{name} -->"}
+end

data/bin/cog

@@ -1,10 +1,6 @@
 #!/usr/bin/env ruby
 require 'gli'
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 require 'cog'
-require 'active_support/core_ext'
-require 'fileutils'
-require 'rainbow'
 
 include GLI::App
 
@@ -13,18 +9,13 @@ program_desc 'This is a utility to help you write code generators.'
 desc 'Current version of cog'
 version Cog::VERSION
 
-desc 'Output more detailed information when running a command'
-switch [:verbose]
+desc 'When listing files, show the full path to the file'
+switch :fullpaths
 
 desc 'Set the Cogfile explicitly'
 arg_name 'path'
 flag :cogfile
 
-desc 'Set the active tool'
-arg_name 'name'
-default_value 'basic'
-flag [:tool, :t]
-
 desc 'Suppress the use of color in output'
 switch :colorless
 
@@ -44,7 +35,7 @@ command [:generator, :gen] do |c|
   c.desc 'List project generators'
   c.command :list do |sub|
     sub.action do |gopt, opt, args|
-      x = Cog::Controllers::GeneratorController.list :verbose => gopt[:v]
+      x = Cog::Controllers::GeneratorController.list
       puts x.join "\n" unless x.empty?
     end
   end
@@ -56,13 +47,18 @@ command [:generator, :gen] do |c|
     sub.default_value 'in Cogfile'
     sub.flag [:language, :l]
     
+    sub.desc 'Specify the plugin which will be used to create the generator'
+    sub.arg_name 'name'
+    sub.default_value 'basic'
+    sub.flag [:plugin, :p]
+    
     sub.action do |gopt, opt, args|
       args.each do |name|
         if opt[:language] && opt[:language] != 'in Cogfile'
           lang = Cog::Languages.get_language opt[:language]
           Cog.target_language = lang
         end
-        Cog::Controllers::GeneratorController.create name
+        Cog::Controllers::GeneratorController.create name, :plugin_name => opt[:plugin]
       end
     end
   end
@@ -72,35 +68,37 @@ 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.project?
       Cog::Embeds.gather_from_project
-      args = Cog::Controllers::GeneratorController.list if args.empty?
-      args.each do |name|
-        Cog::Controllers::GeneratorController.run name
+      if args.empty?
+        Cog::Controllers::GeneratorController.run_all
+      else
+        args.each do |name|
+          Cog::Controllers::GeneratorController.run name
+        end
       end
     end
   end
 end
 
-desc 'List or create DSLs known as cog tools'
-command :tool do |c|
+desc 'List or create DSLs known as cog plugins'
+command :plugin do |c|
   
   c.default_command :list
   
-  c.desc 'List the available tools'
+  c.desc 'List the available plugins'
   c.command :list do |sub|
     sub.action do |gopt, opt, args|
-      x = Cog::Controllers::ToolController.list :verbose => gopt[:verbose]
+      x = Cog::Controllers::PluginController.list
       puts x.join "\n" unless x.empty?
     end
   end
   
-  c.desc 'Create a new tool'
-  c.arg_name 'tool_name'
+  c.desc 'Create a new plugin'
+  c.arg_name 'plugin_name'
   c.command :new do |sub|
     sub.action do |gopt, opt, args|
       args.each do |name|
-        Cog::Controllers::ToolController.create name
+        Cog::Controllers::PluginController.create name
       end
     end
   end
@@ -114,24 +112,17 @@ command [:template, :tm] do |c|
   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]
+      x = Cog::Controllers::TemplateController.list
       puts x.join "\n" unless x.empty?
     end
   end
   
   c.desc 'Create a new project template'
   c.command :new do |sub|
-    sub.desc 'Force override of existing built-in or tool templates'
-    sub.switch ['force-override', :f]
-    
+
     sub.action do |gopt, opt, args|
       args.each do |name|
-        begin
-          Cog::Controllers::TemplateController.create name, :force_override => opt[:f]
-        rescue Cog::Errors::DuplicateTemplate => e
-          STDERR.write "Use --force-override to copy the original template into your project templates\n"
-          raise
-        end
+        Cog::Controllers::TemplateController.create name, :force_override => opt[:f]
       end
     end
   end
@@ -161,11 +152,11 @@ pre do |gopt, command, opt, args|
     STDERR.write "No such Cogfile at #{gopt[:cogfile]}\n"
     false
   else
-    Cog.prepare :cogfile_path => gopt[:cogfile]
-    unless command.name == :init
-      Cog.register_tools
-      Cog.activate_tool gopt[:tool]
-    end
+    Cog.prepare(
+      :minimal => command.name == :init,
+      :project_cogfile_path => gopt[:cogfile],
+      :fullpaths => gopt[:fullpaths]
+      )
     true
   end
 end

data/built_in/generators/sort.rb

@@ -0,0 +1,3 @@
+embed 'sort' do |c|
+  c.body.split("\n").sort.join("\n")
+end

data/built_in/plugins/basic/Cogfile

@@ -0,0 +1,6 @@
+template_path 'templates'
+
+stamp_generator do |name, dest|
+  @name = name
+  stamp 'basic/generator.rb', dest, :absolute_destination => true
+end

data/built_in/plugins/basic/templates/basic/generator.rb.erb

@@ -0,0 +1 @@
+# This is the <%= @name %> generator

data/built_in/templates/cog/Cogfile.erb

@@ -0,0 +1,40 @@
+# All paths are relative to the directory containing this file.
+
+<% if @cogfile_type == :plugin %>
+stamp_generator do |name, dest|
+  @name = name
+  stamp '<%= @plugin_name %>/generator.rb', dest, :absolute_destination => true
+end
+
+autoload_plugin :<%= @plugin_module %>, 'lib/<%= @plugin_name %>'
+
+<% end %>
+<% if @cogfile_type == :project %>
+# Define the directory to which code is generated
+project_path 'lib'
+
+<% end %>
+# Define a directory in which to find generators
+generator_path '<%= @prefix %>generators'
+
+# Define a directory in which to find templates
+template_path '<%= @prefix %>templates'
+
+<% unless @cogfile_type == :plugin %>
+# Define a directory in which to find plugins
+plugin_path '<%= @prefix %>plugins'
+
+<% end %>
+<% if @cogfile_type == :project %>
+# Explicitly specify a mapping from file extensions to languages
+#
+# key => value pairs from this mapping will override the default
+# language map supplied by +cog+
+#
+# Type `cog language list` to see a list of supported languages
+# and the current file extension mappings
+language_extensions({
+  :h => 'c++',
+})
+
+<% end %>

data/built_in/templates/cog/plugin/generator.rb.erb.erb

@@ -0,0 +1,3 @@
+<%= @plugin_module %>.widget '<%%= @name %>' do |w|
+  w.context = 'this is the context'
+end

data/{templates/cog/custom_tool/tool.rb.erb → built_in/templates/cog/plugin/plugin.rb.erb}

@@ -1,22 +1,15 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__))
-require '<%= @tool_name %>/version'
 require 'cog'
 
-# Custom cog tool <%= @tool_name %> 
-module <%= @tool_module %> 
+# Custom cog plugin <%= @plugin_name %> 
+module <%= @plugin_module %> 
   
   # Root of the DSL
   # Feel free to rename this to something more appropriate
   def self.widget(generator_name, &block)
     w = Widget.new generator_name
     block.call w
-    
-    # Activate <%= @tool_name %> while rendering templates
-    # so that cog will be able to find <%= @tool_name %> templates
-    Cog.activate_tool '<%= @tool_name %>' do
-      w.generate
-    end
-    
+    w.generate
     nil
   end
 
@@ -34,7 +27,7 @@ module <%= @tool_module %>
     end
     
     def generate
-      stamp '<%= @tool_name %>/<%= @tool_name %>.txt', "generated_#{@generator_name}.txt"
+      puts "TODO: write generator code for <%= @plugin_name %>"
     end
   end
 end

data/lib/cog.rb

@@ -1,23 +1,37 @@
-require 'cog/config'
-require 'cog/controllers'
-require 'cog/embeds'
+require 'active_support/core_ext'
+require 'fileutils'
+require 'rainbow'
+
 require 'cog/errors'
-require 'cog/generator'
-require 'cog/helpers'
-require 'cog/languages'
-require 'cog/tool'
-require 'cog/version'
+require 'cog/native_extensions'
 
-# This top level module serves as a singleton instance of the {Config} interface.
+# This top level module serves as a singleton instance of the {Config} interface. It is configured with various cogfiles, which are evaluated as instances of {DSL::Cogfile}.
 module Cog
 
+  autoload :Config, 'cog/config'
+  autoload :Controllers, 'cog/controllers'
+  autoload :DSL, 'cog/dsl'
+  autoload :EmbedContext, 'cog/embed_context'
+  autoload :Embeds, 'cog/embeds'
+  autoload :Generator, 'cog/generator'
+  autoload :GeneratorSandbox, 'cog/generator_sandbox'
+  autoload :Helpers, 'cog/helpers'
+  autoload :Language, 'cog/language'
+  autoload :Plugin, 'cog/plugin'
+  autoload :VERSION, 'cog/version'
+  
   extend Config
   
   # Prepare the project in the present working directory for use with +cog+
   # @return [nil]
   def self.initialize_project
-    Generator.copy_file_if_missing File.join(Cog.gem_dir, 'Default.cogfile'), 'Cogfile'
-    Cog.prepare :force_reset => true
+    @cogfile_type = :project
+    @prefix = 'cog/'
+    Generator.stamp 'cog/Cogfile', 'Cogfile', :absolute_destination => true, :binding => binding, :once => true
+    
+    @cogfile_type = :user
+    @prefix = ''
+    Generator.stamp 'cog/Cogfile', user_cogfile, :absolute_destination => true, :binding => binding, :once => true
     nil
   end
 

data/lib/cog/config.rb

@@ -1,24 +1,24 @@
-require 'cog/config/cogfile'
-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 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] Location of the built-in templates
-    def cog_templates_path
-      File.join Cog.gem_dir, 'templates'
-    end
+    autoload :LanguageConfig, 'cog/config/language_config'
+    autoload :ProjectConfig, 'cog/config/project_config'
+    autoload :PluginConfig, 'cog/config/plugin_config'
+    
+    include ProjectConfig
+    include LanguageConfig
+    include PluginConfig
+
+    # @return [Array<String>] directories in which to find generators
+    attr_reader :generator_path
+
+    # @return [Array<String>] directories in which to find templates
+    attr_reader :template_path
+
+    # @return [Array<String>] directories in which to find plugins
+    attr_reader :plugin_path
 
     # @return [String] Location of the installed cog gem
     def gem_dir
@@ -31,53 +31,110 @@ module Cog
         spec.gem_dir
       end
     end
+
+    # @return [String,nil] if installed as a gem, return the parent directory of the gem's location
+    def gems_root_dir
+      x = gem_dir
+      File.expand_path(File.join(x, '..')) unless File.exists?(File.join(x, 'Gemfile'))
+    end
+
+    # @return [String] Path to <tt>${HOME}/.cog</tt>
+    def user_dir
+      File.expand_path File.join(ENV['HOME'], '.cog')
+    end
+    
+    # @return [String] Path to the current user's cogfile
+    def user_cogfile
+      File.join user_dir, 'Cogfile'
+    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)
-    # * {#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
+    # @return [Boolean] when listing files, full paths should be shown
+    def show_fullpaths?
+      @fullpaths
     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
+    # @option opt [Boolean] :fullpaths (false) when listing files, full paths should be shown
+    # @option opt [Boolean] :minimal (false) only load the built-in Cogfile
+    # @option opt [String] :project_cogfile_path (nil) explicitly specify the location of the project {DSL::Cogfile}. If not provided, it will be searched for. If none can be found, {#project?} will be +false+
     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
-      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
+      @fullpaths = opt[:fullpaths]
+      @project_path = nil
+      @project_generator_path = nil
+      @project_plugin_path = nil
+      @project_template_path = nil
+      @generator_path = []
+      @plugin_path = []
+      @template_path = []
+      @plugins = {}
+      @target_language = Language.new
+      @active_languages = [Language.new] # active language stack
+      @language = {}
+      @language_extension_map = {}
+      
+      process_cogfiles opt
+      post_cogfile_processing
+      build_language_extension_map
     end
     
     private
     
-    # The {Cogfile} will be looked for in the present working directory. If none
+    # @option opt [Boolean] :minimal (false) only load the built-in Cogfile
+    # @option opt [String] :project_cogfile_path (nil) project cogfile
+    def process_cogfiles(opt={})
+      @project_cogfile_path = opt[:project_cogfile_path] || find_default_cogfile
+      if @project_cogfile_path
+        @project_cogfile_path = File.expand_path @project_cogfile_path
+        @project_root = File.dirname @project_cogfile_path
+      end
+      process_cogfile built_in_cogfile
+      return if opt[:minimal]
+      process_cogfile user_cogfile if File.exists? user_cogfile
+      process_cogfile @project_cogfile_path, :plugin_path_only => true if @project_cogfile_path
+      plugins.each do |plugin|
+        process_cogfile plugin.cogfile_path, :plugin => plugin
+      end
+      process_cogfile @project_cogfile_path, :project => true if @project_cogfile_path
+    end
+    
+    # @param path [String] path to the cogfile
+    # @option opt [Boolean] :plugin_path_only (false) only process +plugin_path+ calls in the given cogfile
+    # @option opt [Boolean] :active_plugin (false) process the +stamp_generator+ call in the given cogfile
+    # @option opt [Plugin] :plugin (nil) indicate that the cogfile is for the given plugin
+    def process_cogfile(path, opt={})
+      cogfile = DSL::Cogfile.new self, path, opt
+      cogfile.interpret
+    end
+    
+    def post_cogfile_processing
+      @language.each_value do |lang|
+        if lang.comment_style != lang.key
+          other = @language[lang.comment_style]
+          lang.apply_comment_style other
+        end
+        if lang.include_guard_style != lang.key
+          other = @language[lang.include_guard_style]
+          lang.apply_include_guard_style other
+        end
+      end
+    end
+    
+    def build_language_extension_map
+      @language.each_value do |lang|
+        lang.extensions.each do |ext|
+          @language_extension_map[ext] = lang.key unless @language_extension_map.member?(ext)
+        end
+      end
+    end
+    
+    # The {DSL::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
+    # @return [Config, nil] the singleton instance
     def find_default_cogfile
       parts = Dir.pwd.split File::SEPARATOR
       i = parts.length
@@ -87,5 +144,11 @@ module Cog
       path = File.join(parts.slice(0, i) + ['Cogfile']) if i >= 0
       (path && File.exists?(path)) ? path : nil
     end
+    
+    # @return [String] path to the built-in cogfile
+    def built_in_cogfile
+      File.join gem_dir, 'BuiltIn.cogfile'
+    end
+    
   end
 end