rabal 0.0.1 → 0.1.0

data/lib/rabal/logger.rb

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

data/lib/rabal/plugin.rb

@@ -1,5 +1,9 @@
-require 'rubygems'
-require 'gem_plugin'
-
-# load up all the builtin plugins
-Rabal.require_all_libs_relative_to(__FILE__)
+# load up all the builtin rabal/plugins
+require 'rabal/plugin/bin'
+require 'rabal/plugin/core'
+require 'rabal/plugin/ext'
+require 'rabal/plugin/foundation'
+require 'rabal/plugin/license'
+require 'rabal/plugin/rubyforge'
+require 'rabal/plugin/spec'
+require 'rabal/plugin/test'

data/lib/rabal/plugin/core.rb

@@ -2,8 +2,9 @@ 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"
+            parameter "author", "Author of the project (full name)", lambda { |x| x.length > 2 } 
+            # validating non-perfect email from regular-expressions.info
+            parameter "email", "Email address of the author", lambda { |x| x =~ /\A[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\Z/i }
             use_always
             description <<-DESC
             The core functionality and baseline information needed by every project.  
@@ -16,7 +17,7 @@ module Rabal
             def initialize(options)
                 @parameters = OpenStruct.new(options)
                 validate_parameters
-                @tree = ProjectTree.new(options[:project] || options["project"],options)
+                @tree = ProjectTree.new(options[:project] || options["project"],@parameters)
                 @tree << PluginTree.new({},resource_by_name(my_main_tree_name))
             end
         end

data/lib/rabal/plugin/ext.rb

@@ -0,0 +1,17 @@
+require 'rabal/plugin/foundation'
+module Rabal
+    module Plugin
+        class Ext < Rabal::Plugin::Base "/rabal/ext"
+            description "Add a ruby extension"
+            parameter "soname", "Name of the resulting .so file (e.g.  myext)"
+            parameter "lib_name", "Library to link against (e.g. libsomething)"
+            parameter "lib_method", "Check for the existence of this method in the library"
+
+            def initialize(options)
+                @parameters = OpenStruct.new(options)
+                validate_parameters
+                @tree = PluginTree.new(@parameters.marshal_dump, resource_by_name(my_main_tree_name))
+            end
+        end
+    end
+end

data/lib/rabal/plugin/foundation.rb

@@ -1,6 +1,6 @@
-require 'rabal'
-require 'rubygems'
-require 'main'
+require 'gem_plugin'
+require 'highline/import'
+require 'rabal/logger'
 
 module Rabal
     module Plugin
@@ -38,12 +38,14 @@ module Rabal
                 attribute :register_as => nil
 
                 # part of the mini DSL for describing a Plugin
-                def parameter(pname,description)
+                def parameter(pname,description,block = nil)
                     @parameters ||= {}
-                    @parameters[pname] = [pname, description]
+                    @parameters[pname] = {:name => pname,
+                                          :desc => description,
+                                          :proc => block}
                 end
 
-                # get the parameters bac
+                # get the parameters back
                 def parameters
                     @parameters ||= {}
                 end
@@ -86,19 +88,28 @@ module Rabal
             # 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"
+                self.class.parameters.each do |name,param_info|
+                    if not @parameters.respond_to?(name) or @parameters.send(name).nil? then
+                        value = prompt_for_param(param_info[:name],param_info[:desc],param_info[:proc])
+                        @parameters.send("#{name}=",value)
                     end
                 end
             end
+
+            # prompt the user for the value that we want from them
+            def prompt_for_param(param,desc,validation_proc = nil)
+                ask("#{desc} ? ") do |q| 
+                    q.readline = true 
+                    q.validate = validation_proc 
+                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

data/lib/rabal/plugin/license.rb

@@ -7,28 +7,23 @@ module Rabal
         # 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(', ')}"
+            TYPES = %w[BSD GPL LGPL MIT RUBY]
+            parameter "flavor", "Flavor of License for your project: #{TYPES.join(', ')}", lambda { |x| TYPES.include?(x.upcase) }
             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
+                validate_parameters
                 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."
+                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
             end
         end

data/lib/rabal/plugin/rubyforge.rb

@@ -0,0 +1,22 @@
+require 'rabal/plugin/foundation'
+module Rabal
+    module Plugin
+        class Rubyforge < Rabal::Plugin::Base "/rabal/rubyforge"
+            description "Add rubyforge support"
+            parameter   "rubyforge_project", "The Rubyforge project/umbrella under which this project resides."
+
+            def initialize(options)
+                begin
+                    require 'rubyforge'
+                rescue LoadError
+                    Log::fatal("Unable to use the rubyforge plugin, the rubyforge library is required.")
+                    exit 1
+                end
+
+                @parameters = OpenStruct.new(options)
+                validate_parameters
+                @tree = PluginTree.new(@parameters.marshal_dump, resource_by_name(my_main_tree_name))
+            end
+        end
+    end
+end

data/lib/rabal/plugin/spec.rb

@@ -3,6 +3,12 @@ module Rabal
     module Plugin
         class Spec < Rabal::Plugin::Base "/rabal/spec"
             description "Add an RSpec framework."
+
+            def initialize(options)
+                @parameters = OpenStruct.new(options)
+                validate_parameters
+                @tree = PluginTree.new({}, resource_by_name(my_main_tree_name))
+            end
         end
     end
 end

data/lib/rabal/plugin/test.rb

@@ -3,6 +3,13 @@ module Rabal
     module Plugin
         class Test < Rabal::Plugin::Base "/rabal/test"
             description "Add a Test::Unit framework."
+
+            def initialize(options)
+                @parameters = OpenStruct.new(options)
+                validate_parameters
+                main_tree_name = my_main_tree_name
+                @tree = PluginTree.new({}, resource_by_name(main_tree_name))
+            end
         end
     end
 end

data/lib/rabal/plugin_tree.rb

@@ -1,6 +1,4 @@
 require 'rabal'
-require 'find'
-require 'rabal/util'
 
 module Rabal
     # 
@@ -47,6 +45,7 @@ module Rabal
                 Dir.entries(".").each do |entry|
                     next if entry[0] == ?.
                     next if pwd == entry
+                    next if entry[-1] == ?~
         
                     if File.file?(entry) then
                         tree << FileTree.from_file(entry,true,replace_known_words(entry))

data/lib/rabal/project_tree.rb

@@ -1,4 +1,5 @@
-require 'rabal/directory_tree'
+require 'rabal'
+
 module Rabal
     #
     # The ProjectTree represents the master configuration/specification
@@ -10,8 +11,12 @@ module Rabal
         # and delegate items to a Gem specification.
         def initialize(project_name,options)
             super(project_name)
+            if options.kind_of?(OpenStruct) then
+                options = options.marshal_dump
+            end
             @parameters = OpenStruct.new(options)
-            @parameters.project_name = project_name
+            @parameters.raw_project_name = project_name
+            @parameters.project_name = project_name.gsub(/^ruby-/,'')
         end
     end
 end

data/lib/rabal/specification.rb

@@ -0,0 +1,128 @@
+require 'rubygems'
+require 'rubygems/specification'
+require 'rake'
+
+module Rabal
+    # Add some additional items to Gem::Specification
+    # A Rabal::Specification adds additional pieces of information the
+    # typical gem specification
+    class Specification 
+
+        RUBYFORGE_ROOT = "/var/www/gforge-projects/"
+      
+        # user that accesses remote site
+        attr_accessor :remote_user
+
+        # remote host, default 'rubyforge.org'
+        attr_accessor :remote_host
+
+        # name the rdoc main
+        attr_accessor :rdoc_main
+
+        # local directory in development holding the generated rdoc
+        # default 'doc'
+        attr_accessor :local_rdoc_dir
+
+        # remote directory for storing rdoc, default 'doc'
+        attr_accessor :remote_rdoc_dir
+
+        # local directory for coverage report
+        attr_accessor :local_coverage_dir
+        
+        # remote directory for storing coverage reports
+        # This defaults to 'coverage'
+        attr_accessor :remote_coverage_dir
+
+        # local directory for generated website, default +site/public+
+        attr_accessor :local_site_dir
+       
+        # remote directory relative to +remote_root+ for the website.
+        # website.
+        attr_accessor :remote_site_dir
+
+        # is a .tgz to be created?, default 'true'
+        attr_accessor :need_tar
+
+        # is a .zip to be created, default 'true'
+        attr_accessor :need_zip
+
+
+        def initialize
+            @remote_user = nil
+            @remote_host = "rubyforge.org"
+
+            @rdoc_main              = "README"
+            @local_rdoc_dir         = "doc"
+            @remote_rdoc_dir        = "doc"
+            @local_coverage_dir     = "coverage"
+            @remote_coverage_dir    = "coverage"
+            @local_site_dir         = "site/public"
+            @remote_site_dir        = "."
+            
+            @need_tar   = true
+            @need_zip   = true
+
+            @spec                   = Gem::Specification.new
+
+            yield self if block_given?
+
+            # update rdoc options to take care of the rdoc_main if it is
+            # there, and add a default title if one is not given
+            if not @spec.rdoc_options.include?("--main") then
+                @spec.rdoc_options.concat(["--main", rdoc_main])
+            end
+
+            if not @spec.rdoc_options.include?("--title") then
+                @spec.rdoc_options.concat(["--title","'#{name} -- #{summary}'"])
+            end
+        end
+
+        # if this gets set then it overwrites what would be the
+        # rubyforge default.  If rubyforge project is not set then use
+        # name.  If rubyforge project and name are set, but they are
+        # different then assume that name is a subproject of the
+        # rubyforge project
+        def remote_root 
+            if rubyforge_project.nil? or 
+                rubyforge_project == name then
+                return RUBYFORGE_ROOT + "#{name}/"
+            else
+                return RUBYFORGE_ROOT + "#{rubyforge_project}/#{name}/"
+            end
+        end
+
+        # rdoc files is the same as what would be generated during gem
+        # installation. That is, everything in the require paths plus
+        # the extra_rdoc_files
+        #
+        def rdoc_files 
+            flist = extra_rdoc_files.dup
+            @spec.require_paths.each do |rp|
+                flist << FileList["#{rp}/**/*.rb"]
+            end
+            flist.flatten.uniq
+        end
+
+        # calculate the remote directories
+        def remote_root_location
+            "#{remote_user}@#{remote_host}:#{remote_root}"
+        end
+           
+        def remote_rdoc_location
+            remote_root_location + @remote_rdoc_dir
+        end
+
+        def remote_coverage_location
+            remote_root_loation + @remote_coverage_dir
+        end
+
+        def remote_site_location
+            remote_root_location + @remote_site_dir
+        end
+
+        # we delegate any other calls to spec
+        def method_missing(method_id,*params,&block)
+            @spec.send method_id, *params, &block
+        end
+    end
+end

data/lib/rabal/tree.rb

@@ -1,4 +1,4 @@
-require 'rabal'
+require 'rabal/logger'
 
 module Rabal
     #
@@ -120,10 +120,14 @@ module Rabal
             end
 
             subtree.parent = self
+           
+            # FIXME: techinically this should no longer be called 'post_add' 
+            # but maybe 'add_hook'  
+            subtree.post_add
 
             # 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.
+            # just put the new subtree's children into the children of
+            # the already existing subtree.
             if children.has_key?(subtree.name) then
                 subtree.children.each do |n,tree|
                     children[n] = tree
@@ -131,8 +135,6 @@ module Rabal
             else
                 children[subtree.name] = subtree
             end
-           
-            subtree.post_add
 
             return self
         end
@@ -213,6 +215,18 @@ module Rabal
             end
         end
 
+        #
+        # Return true of false if the given subtree exists or not
+        #
+        def has_subtree?(path)
+            begin
+                find_subtree(path)
+                return true
+            rescue PathNotFoundError
+                return false
+            end
+        end
+
         private
 
         #