rabal 0.0.1

data/lib/rabal/logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+module Rabal
+    module Log
+        LOGGER                 = Logger.new(STDOUT)
+        LOGGER.datetime_format = "%Y-%m-%d %H:%M:%S"
+
+
+        class << self
+            %w(debug info warn error fatal).each do |m|
+                module_eval <<-code 
+                    def #{ m } *a, &b
+                        LOGGER.#{ m } *a, &b
+                    end
+                code
+            end
+        end
+    end
+end

data/lib/rabal/plugin/bin.rb

@@ -0,0 +1,8 @@
+require 'rabal/plugin/foundation'
+module Rabal
+    module Plugin
+        class Bin < Rabal::Plugin::Base "/rabal/bin"
+            description "Add a commandline application."
+        end
+    end
+end

data/lib/rabal/plugin/core.rb

@@ -0,0 +1,24 @@
+require 'rabal/plugin/foundation'
+module Rabal
+    module Plugin
+        class Core < Rabal::Plugin::Base "/rabal/core"
+            parameter "author", "Author of the project" 
+            parameter "email", "Email address of the author"
+            use_always
+            description <<-DESC
+            The core functionality and baseline information needed by every project.  
+            DESC
+
+            # core is slightly different from the default and uses a
+            # ProjecTree instead of a PluginTree.  It does attach a
+            # PluginTree below the project tree with the basic file
+            # structure
+            def initialize(options)
+                @parameters = OpenStruct.new(options)
+                validate_parameters
+                @tree = ProjectTree.new(options[:project] || options["project"],options)
+                @tree << PluginTree.new({},resource_by_name(my_main_tree_name))
+            end
+        end
+    end
+end

data/lib/rabal/plugin/foundation.rb

@@ -0,0 +1,154 @@
+require 'rabal'
+require 'rubygems'
+require 'main'
+
+module Rabal
+    module Plugin
+        #
+        # Base plugin that all other plugins will inherit from, but not
+        # directly.  New plugins are declared with:
+        #
+        #   class NewPlugin < Rabal::Plugin::Base "/foo/bar"
+        #   ...
+        #   end
+        #
+        # This process uses GemPlugin under the covers, it has just been
+        # wrapped to provide a different +Base+ class for everything to
+        # inherit from.
+        #
+        class Foundation
+
+            # the PluginTree that the plugin creates.
+            attr_reader :tree
+
+            class << self
+
+                # Called when another class inherits from Foundation.
+                # when that happens that class is registered in the
+                # GemPlugin::Manager
+                def inherited(by_class)
+                    register_key = "/" + by_class.to_s.downcase
+                    by_class.register_path register_as
+                    GemPlugin::Manager.instance.register(register_as,register_key,by_class)
+                    register_as = nil
+                end
+
+                # allows Plugin::Base to store the registration
+                # information in the class variable.
+                attribute :register_as => nil
+
+                # part of the mini DSL for describing a Plugin
+                def parameter(pname,description)
+                    @parameters ||= {}
+                    @parameters[pname] = [pname, description]
+                end
+
+                # get the parameters bac
+                def parameters
+                    @parameters ||= {}
+                end
+
+                def use_always?
+                    @use_always
+                end
+
+                def use_always(d = true)
+                    @use_always = d
+                end
+
+                attribute :description =>  "I Need a Description"
+                attribute :register_path
+
+                def use_name
+                    name.split("::").last.dashify
+                end
+            end
+
+            # A Plugin is instantiated and the options passed to it are
+            # the results of the command line options for this plugin.
+            #
+            # The default action for any Plugin is to create a
+            # PluginTree from its options utilizing the +register_path+
+            # to determine a location within the gem's resources.  The
+            # resources is used to instantiate a PluginTree and that is
+            # set to +tree+ and by default, this tree will be 'mounted'
+            # at the root of some other tree.
+            def initialize(options = {})
+                @parameters = OpenStruct.new(options)
+                validate_parameters
+                main_tree_name = my_main_tree_name
+                @tree = PluginTree.new(options,resource_by_name(main_tree_name),
+                                       File.basename(main_tree_name))
+            end
+
+            ############################################################
+            # regular instance methods, provide for convenience to the
+            # child plugins
+            ############################################################
+
+            #
+            # validate the parameters of the plugin in the simplest way
+            # possible.  Make sure that each listend parameters is not
+            # null.  This assumes that @parameters has a method for each
+            # parameter naem
+            #
+            def validate_parameters
+                self.class.parameters.each do |param,desc|
+                    if not @parameters.respond_to?(param) or @parameters.send(param).nil? then
+                        raise PluginParameterMissingError, "Missing parameter '#{param}' from #{self.class.use_name} plugin.  See --use-#{self.class.use_name} --help"
+                    end
+                end
+            end
+            # What gem a plugin belongs to.  This is necessary to access
+            # the resources of the gem the plugin may use.  Overload
+            # this in a child plugin to return what you want.  By
+            # default it uses the first part of the path the gem is
+            # registered under.
+            #
+            # That is when the plugin is defined
+            #
+            #   class MyPlugin < Rabal::Plugin::Base "/my-plugin/something"
+            #   ...
+            #   end
+            #
+            # 'my-plugin' is defined as being the default gem name.
+            def my_gem_name
+                self.class.register_path.split("/").find{|p| p.length > 0}
+            end
+
+            # The main resource for this Plugin.  This is generally a
+            # file or a directory that the plugin will use as a template
+            # and create a PluginTree from.
+            def my_main_tree_name
+                tree_name = self.class.register_path.split("/").find_all {|p| p.length > 0}
+                tree_name.shift
+                tree_name.unshift "trees"
+                tree_name.join("/")
+            end
+
+            # Access a resource utilized by the gem.  The name is the
+            # path to a file or directory under the 'resources'
+            # directory in the gem this plugin is a part of.
+            def resource_by_name(resource_name)
+                Rabal.application.plugin_resource(my_gem_name,resource_name)
+            end
+        end
+    end
+
+    #
+    # This is the happen'n way to do things.  Camping does it,
+    # GemPlugin does it.  Come on You can do it too.
+    #
+    # Put +register_path+ into the class variable @@path of
+    # Plugin::Foundation and then return the Plugin::Foundation class
+    # which will be used as the parent class for the new class.  
+    #
+    # Upon declaration of the new class, Foundation.inherited will be
+    # invoked which will register the new class with GemPlugin::Manager
+    # an clear out @@path 
+    #
+    def Plugin::Base(register_path)
+        Plugin::Foundation.register_as = register_path
+        Plugin::Foundation
+    end
+end

data/lib/rabal/plugin/license.rb

@@ -0,0 +1,36 @@
+require 'rabal/plugin/foundation'
+module Rabal
+    module Plugin
+        #
+        # The license plugin helps the user pick a license for their
+        # project.  The current available license to choose from are
+        # BSD, GPL, LGPG, MIT and Ruby
+        #
+        class License < Rabal::Plugin::Base "/rabal/license"
+            TYPES = %w[BSD GPL LGPL MIT Ruby]
+            parameter "flavor", "Flavor of License for your project: #{TYPES.join(', ')}"
+            description "Indicate under what license your project is released."
+            use_always
+
+            def initialize(options)
+                @parameters = OpenStruct.new(options)
+                if not @parameters.respond_to?(:flavor) then
+                    raise PluginParameterMissingError, "Missing parameter 'flavor' from license plugin.  See --use-license --help"
+                end
+                suffix = @parameters.flavor
+                # look at all files in our resource directory and any
+                # that have the same suffix as the 'flavor' load it into
+                # the tree.
+                if TYPES.include?(suffix) then
+                    resource_dir = resource_by_name(my_main_tree_name)
+                    @tree = DirectoryTree.new(".")
+                    Dir.glob(File.join(resource_dir,"*.#{suffix.downcase}")).each do |file|
+                        @tree << FileTree.from_file(file)
+                    end
+                else
+                    raise PluginParameterMissingError, "Invalid value '#{suffix}' for 'flavor' parameter from license plugin.  Only #{TYPES.join(",")} are currently supported."
+                end
+            end
+        end
+    end
+end

data/lib/rabal/plugin/spec.rb

@@ -0,0 +1,8 @@
+require 'rabal/plugin/foundation'
+module Rabal
+    module Plugin
+        class Spec < Rabal::Plugin::Base "/rabal/spec"
+            description "Add an RSpec framework."
+        end
+    end
+end

data/lib/rabal/plugin/test.rb

@@ -0,0 +1,8 @@
+require 'rabal/plugin/foundation'
+module Rabal
+    module Plugin
+        class Test < Rabal::Plugin::Base "/rabal/test"
+            description "Add a Test::Unit framework."
+        end
+    end
+end

data/lib/rabal/plugin.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'gem_plugin'
+
+# load up all the builtin plugins
+Rabal.require_all_libs_relative_to(__FILE__)

data/lib/rabal/plugin_tree.rb

@@ -0,0 +1,61 @@
+require 'rabal'
+require 'find'
+require 'rabal/util'
+
+module Rabal
+    # 
+    # Represents the root of a plugin directory structure.  This plugin
+    # could also only represent a single FileTree by having the
+    # 'directory' it represents being '.'
+    #
+    class PluginTree < DirectoryTree
+
+        include Util
+
+        # the source directory from which the project is generated 
+        attr_accessor :src_directory
+
+        # create a new Plugin Tree based upon a source directory.  This
+        # 'mounts' the src_directory into the dest_directory in the
+        # project.  The dest_directory defaults to "." .  The +options+
+        # are a hash that are propogated to the +parameters+ member
+        # variable.
+        def initialize(options,src_directory,dest_directory= ".")
+            super(dest_directory)
+            @src_directory = src_directory
+            @parameters = OpenStruct.new(options)
+        end
+
+        #
+        # populating the tree needs to take place after the PluginTree
+        # has been added to the Tree, but before the processing of the
+        # tree takes place
+        # 
+        def post_add
+            populate_tree(src_directory)
+        end
+
+        private
+
+        # 
+        # Given a source directory populate a PluginTree based upon the
+        # contents of the directory.  All files will be mapped to
+        # FileTree and directories will be mapped to DirectoryTree.
+        #
+        def populate_tree(src_directory,tree=self)
+            Dir.chdir(src_directory) do |pwd|
+                Dir.entries(".").each do |entry|
+                    next if entry[0] == ?.
+                    next if pwd == entry
+        
+                    if File.file?(entry) then
+                        tree << FileTree.from_file(entry,true,replace_known_words(entry))
+                    elsif File.directory?(entry) then
+                        tree << dir = DirectoryTree.new(replace_known_words(entry))
+                        populate_tree(entry,dir)
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/rabal/project_tree.rb

@@ -0,0 +1,17 @@
+require 'rabal/directory_tree'
+module Rabal
+    #
+    # The ProjectTree represents the master configuration/specification
+    # of a project.
+    #
+    class ProjectTree < DirectoryTree
+
+        # FIXME: this should derive a whole bunch of instance variables
+        # and delegate items to a Gem specification.
+        def initialize(project_name,options)
+            super(project_name)
+            @parameters = OpenStruct.new(options)
+            @parameters.project_name = project_name
+        end
+    end
+end

data/lib/rabal/tree.rb

@@ -0,0 +1,231 @@
+require 'rabal'
+
+module Rabal
+    #
+    # A basic Tree structure
+    #
+    class Tree
+
+        include Enumerable
+
+        # The name of this Tree
+        attr_accessor :name
+
+        # The parent of this node.  If this is nil then this Tree is a
+        # root.
+        attr_accessor :parent
+
+        # The children of this node.  If this Array is empty, then this
+        # Tree is a leaf.
+        attr_accessor :children
+
+        # An abstract data point that can be utilized by child classes
+        # for whatever they like.  If this is non-nil and responds to
+        # method calls it will be searched as part of the
+        # 'method_missing' protocol.
+        attr_accessor :parameters
+
+        #
+        # Create a new Tree with the given object.to_s as its +name+.
+        #
+        def initialize(name)
+            @name       = name.to_s
+            @parent     = nil
+            @children   = {}
+            @parameters = nil
+        end
+
+        #
+        # Return true if this Tree has no children.
+        #
+        def is_leaf?
+            @children.empty?
+        end
+
+        # 
+        # Return true if this Tree has no parent.
+        #
+        def is_root?
+            @parent.nil?
+        end
+
+        # 
+        # Return the root node of the tree
+        #
+        def root
+            return self if is_root?
+            return @parent.root
+        end
+
+        #
+        # Return the distance from the root
+        #
+        def depth
+            return 0 if is_root?
+            return (1 + @parent.depth)
+        end
+
+        #
+        # Attach the given tree at the indicated path.  The path given
+        # is always assumed to be from the root of the Tree being
+        # attached to.
+        #
+        # The path is given as a string separated by '/'.  Each portion
+        # of the string is matched against the name of the particular
+        # tree.  
+        #
+        # Given :
+        #
+        #   a --- b --- c
+        #    \ 
+        #     d - e --- f
+        #          \
+        #           g - h
+        #
+        # * the path +a/b/c+ will match the path to Tree +c+
+        # * the path +d/e/g+ will _not_ match anything as the path must start at +a+ here
+        # * the path +a/d/e+ will _not_ match anytthin as +e+ is not a child of +d+
+        # * the path +a/d/e/g+ will match node +g+
+        #
+        # Leading and trailing '/' on the path are not necessary and removed.
+        #
+        def add_at_path(path,subtree)
+            parent_tree = tree_at_path(path)
+            parent_tree << subtree
+            return self
+        end
+
+
+        #
+        # Return the Tree that resides at the given path
+        #
+        def tree_at_path(path_str)
+            path_str = path_str.chomp("/").reverse.chomp("/").reverse
+            path     = path_str.split("/")
+
+            # strip of the redundant first match if it is the same as
+            # the current node
+            find_subtree(path)
+        end
+
+        #
+        # Add the given object to the Tree as a child of this node.  If
+        # the given object is not a Tree then wrap it with a Tree.
+        #
+        def <<(subtree)
+            # this should not generally be the case, but wrap things
+            # up to be nice.
+            if not subtree.kind_of?(Tree) then
+                subtree = Tree.new(subtree)
+            end
+
+            subtree.parent = self
+
+            # Don't overwrite any existing children with the same name,
+            # just put this one's children in that one, I think this
+            # works recursively now.
+            if children.has_key?(subtree.name) then
+                subtree.children.each do |n,tree|
+                    children[n] = tree
+                end
+            else
+                children[subtree.name] = subtree
+            end
+           
+            subtree.post_add
+
+            return self
+        end
+
+        alias :add :<<
+
+        #
+        # Allow for Enumerable to be included.  This just wraps walk.
+        #
+        def each
+            self.walk(self,lambda { |tree| yield tree }) 
+        end
+
+        #
+        # Count how many items are in the tree
+        #
+        def size
+            inject(0) { |count,n| count + 1 }
+        end
+        
+        # 
+        # Walk the tree in a depth first manner, visiting the Tree
+        # first, then its children
+        #
+        def walk(tree,method)
+            method.call(tree)
+            tree.children.each_pair do |name,child|
+                walk(child,method) 
+            end
+        end
+
+        # 
+        # Allow for a method call to cascade up the tree looking for a
+        # Tree that responds to the call.
+        #
+        def method_missing(method_id,*params,&block)
+            if not parameters.nil? and parameters.respond_to?(method_id) then
+                return parameters.send(method_id, *params, &block)
+            elsif not is_root? then
+                @parent.send method_id, *params, &block
+            else
+                raise NoMethodError, "undefined method `#{method_id}' for #{name}:Tree"
+            end
+        end
+
+
+        #
+        # allow for a hook so newly added Tree objects may do custom
+        # processing after being added to the tree, but before the tree
+        # is walked or processed
+        #
+        def post_add
+        end
+        #
+        # find the current path of the tree from root to here, return it
+        # as a '/' separates string.
+        #
+        def current_path
+            return "*#{name}*" if is_root? 
+            return ([name,parent.current_path]).flatten.reverse.join("/")
+        end
+
+        #
+        # Given the initial path to match as an Array find the Tree that
+        # matches that path.
+        # 
+        def find_subtree(path)
+           
+            if path.empty? then
+                return self
+            else
+                possible_child = path.shift
+                if children.has_key?(possible_child) then
+                    children[possible_child].find_subtree(path)
+                else
+                    raise PathNotFoundError, "`#{possible_child}' does not match anything at the current path in the Tree (#{current_path})"
+                end
+            end
+        end
+
+        private
+
+        #
+        # Log to the Rabal::Log padding the message with 2 spaces *
+        # depth.
+        #
+        %w(debug info warn error fatal).each do |m|
+            class_eval <<-code
+                def #{ m }(msg)
+                    msg = ("  " * depth) +  msg
+                    Rabal::Log.#{ m }(msg)
+                end
+            code
+        end
+    end
+end

data/lib/rabal/usage.rb

@@ -0,0 +1,100 @@
+require 'main'
+module Rabal
+
+    # Rabal has unique Usage output requirements and as such the default
+    # usage provided by the Main gem although nice are not sufficient.
+    # 
+    # Rabal requires the Usage to be generated after the parameters have
+    # been parsed as the parameters that are on the commandline
+    # determine how the help is printed.
+    class Usage
+
+        attr_reader :app
+        attr_reader :old_usage
+
+        def initialize(app)
+            @app = app
+            @old_usage = {}
+            app.main.usage.each_pair do |key,value|
+                @old_usage[key] = value
+            end
+        end
+
+        # some of the generated usage is quite useful, others we want
+        # to dump, or rename
+        def to_s
+            u = ::Main::Usage.new
+            # just transfer directly over these
+            %w[name synopsis description].each do |chunk|
+                u[chunk.dup] = old_usage[chunk].to_s
+            end
+
+            arguments       = app.main.parameters.select{|p| p.type == :argument}
+            global_options  = app.main.parameters.select{|p| p.type == :option and app.global_option_names.include?(p.name) }
+            load_options    = app.main.parameters.select{|p| p.type == :option and app.plugin_load_option_names.include?(p.name) }
+            plugin_options  = app.main.parameters.select{|p| p.type == :option and app.plugin_option_names.include?(p.name) }
+
+            # rework the formatting of the parameters limiting them to
+            # the globals, force 
+            u['global options'] = section_options("  ",global_options)
+
+            # format the available modules
+            s = ""
+            s << ::Main::Util.columnize("Force any module to be used by giving the --use-[modulename] option.  Modules with a '*' next to them are always used.",:indent => 0, :width => 72)
+            s << "\n\n"
+            s << ""
+            module_options = []
+            app.plugin_manager.plugins.sort_by{|c,p| c}.each do |cat,plugins|
+                 plugins.each do |key,plugin|
+                     pre = "  " + (plugin.use_always? ? "*" : " ")
+                     s << option_format(pre,"#{plugin.use_name} (#{plugin.register_path})",plugin.description,30,32,78)
+                     s << "\n"
+
+                     # create the module options for this one, if the
+                     # plugin is use_always.
+                     if app.main.parameters['use-all'].given? or plugin.use_always? or 
+                         app.main.parameters["use-#{plugin.use_name}"].given? then
+                        plugin_options = app.main.parameters.select{|p| p.type == :option and p.name =~ %r{^#{plugin.use_name}}}
+                        module_options << ["Module options - #{plugin.use_name.camelize}", section_options("  ",plugin_options)]
+                     end
+                 end
+            end
+
+
+            u['Available Modules'] = s
+       
+            module_options.each { |k,v| u[k] = v }
+
+            u['author'] = old_usage['author']
+            u.to_s
+        end
+
+        # take in an option and a description and some formatting
+        # criteria and format a single option
+        def option_format(pre,option,description,col1,col2,width)
+            s = ""
+            s << "#{pre}#{option}".ljust(col1)
+            if description then
+                lines = ::Main::Util.columnize(description,:indent => col2, :width => width).split("\n")
+                inter_first = ' ' * (col2 - col1 - 2) 
+                s << lines.shift.sub(/^\s*/,"#{inter_first}- ")
+                if lines.size > 0 then
+                    s << "\n"
+                    s << lines.join("\n")
+                end
+            end
+            s
+        end
+
+        def section_options(pre,list)
+            if list.size == 0 then
+                return "No options available\n"
+            end
+            list.sort_by{|p| p.name}.collect do |p|
+                ps = ""
+                ps << option_format(pre,p.short_synopsis,p.description,35,39,78)
+                ps
+            end.join("\n")
+        end
+    end
+end