rabal 0.2.3 → 0.3.3

data/lib/rabal/application.rb

@@ -46,7 +46,7 @@ module Rabal
             # only going to happen if run from outside a gem.  Basically
             # while Jeremy is testing. 
             if not plugin_manager.loaded?("rabal") then
-                plugin_manager.gems["rabal"] = ROOT_DIR
+                plugin_manager.gems["rabal"] = Rabal.root_dir
             end
 
 
@@ -93,9 +93,9 @@ module Rabal
         def main
             return @main if @main
             @main = Main.new(app_argv) {
-
-                description Rabal::SPEC.description
-                author      Rabal::SPEC.author
+                
+                description "Rabal is the Ruby Architecture for Building Applications and Libraries."
+                author      "Jeremy Hinegardner <jeremy@hinegardner.org>"
                 version     Rabal::VERSION
 
                 # Project, the whole reason rabal exists

data/lib/rabal/plugin/foundation.rb

@@ -1,6 +1,7 @@
 require 'gem_plugin'
 require 'highline/import'
 require 'rabal/logger'
+require 'fattr'
 
 module Rabal
     module Plugin
@@ -35,7 +36,7 @@ module Rabal
 
                 # allows Plugin::Base to store the registration
                 # information in the class variable.
-                attribute :register_as => nil
+                fattr :register_as => nil
 
                 # part of the mini DSL for describing a Plugin
                 def parameter(pname,description,block = nil)
@@ -58,8 +59,8 @@ module Rabal
                     @use_always = d
                 end
 
-                attribute :description =>  "I Need a Description"
-                attribute :register_path
+                fattr :description =>  "I Need a Description"
+                fattr :register_path
 
                 def use_name
                     name.split("::").last.dashify

data/lib/rabal/version.rb

@@ -1,21 +1,23 @@
 require 'rabal'
 
 module Rabal
-    class Version
-        MAJOR   = 0
-        MINOR   = 2 
-        BUILD   = 3
+  module Version
+    MAJOR   = 0
+    MINOR   = 3 
+    BUILD   = 3
 
-        class << self
-            def to_a
-                [MAJOR, MINOR, BUILD]
-            end
+    def to_a
+      [MAJOR, MINOR, BUILD]
+    end
 
-            def to_s
-                to_a.join(".")
-            end
-        end
-    end 
-    VERSION = Version.to_s
+    def to_s
+      to_a.join(".")
+    end
+    module_function :to_a
+    module_function :to_s
+
+    STRING = Version.to_s
+  end 
+  VERSION = Version.to_s
 end
 

data/resources/trees/bin/rabal.project

@@ -1,12 +1,11 @@
 #!/usr/bin/env ruby
 
-begin
-    require '<%= project_name %>'
-rescue LoadError 
-    path = File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
-    raise if $:.include?(path)
-    $: << path
-    retry
-end
+#--
+# Copyright (c) <%= Date.today.year %> <% author %>
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require '<%= project_name %>'
 
 puts "I am the killer app <%= project_name %> at version #{<%= project_name.camelize %>::VERSION}!"

data/resources/trees/core/HISTORY.erb

@@ -0,0 +1,4 @@
+= Changelog
+== Version 0.0.1
+
+* Initial public release

data/resources/trees/core/README.erb

@@ -13,3 +13,9 @@
 == CREDITS
 
 == LICENSE
+
+Copyright (c) <% Date.today.year %> <%= author %>
+
+All rights reserved.
+
+See LICENSE and/or COPYING for details.

data/resources/trees/core/Rakefile.erb

@@ -1,14 +1,60 @@
-# make sure our project's ./lib directory is added to the ruby search path
-$: << File.join(File.dirname(__FILE__),"lib")
+#--
+# Copyright (c) <%= Date.today.year %> <%= author %>
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
 
+#-------------------------------------------------------------------------------
+# make sure our project's top level directory and the lib directory are added to
+# the ruby search path.
+#-------------------------------------------------------------------------------
+$: << File.expand_path(File.join(File.dirname(__FILE__),"lib"))
+$: << File.expand_path(File.dirname(__FILE__))
+
+
+#-------------------------------------------------------------------------------
+# load the global project configuration and add in the top level clean and
+# clobber tasks so that other tasks can utilize those constants if necessary
+# This loads up the defaults for the whole project configuration
+#-------------------------------------------------------------------------------
 require 'rubygems'
-require 'rake/gempackagetask'
+require 'tasks/config.rb'
 require 'rake/clean'
-require 'rake/rdoctask'
-require 'rake/contrib/sshpublisher'
 
-require '<%= project_name.underscore %>'
+#-------------------------------------------------------------------------------
+# Main configuration for the project, these overwrite the items that are in
+# tasks/config.rb
+#-------------------------------------------------------------------------------
+require '<%= project_name %>'
+Configuration.for("project") {
+  name      "<%= project_name %>"
+  version   <%= project_name.camelize %>::VERSION
+  author    "<%= author %>"
+  email     "<%= email %>"
+  homepage  "http://<%= project_name %>.rubyforge.org/"
+}
 
-load 'tasks/setup.rb'
+#-------------------------------------------------------------------------------
+# load up all the project tasks and setup the default task to be the
+# test:default task.
+#-------------------------------------------------------------------------------
+Configuration.for("packaging").files.tasks.each do |tasklib|
+  import tasklib
+end
+task :default => 'test:default'
 
+#-------------------------------------------------------------------------------
+# Finalize the loading of all pending imports and update the top level clobber
+# task to depend on all possible sub-level tasks that have a name like
+# ':clobber'  in other namespaces.  This allows us to say:
+#
+#   rake clobber
+#
+# and it will get everything.
+#-------------------------------------------------------------------------------
+Rake.application.load_imports
+Rake.application.tasks.each do |t| 
+  if t.name =~ /:clobber/ then
+    task :clobber => [t.name] 
+  end 
+end
 

data/resources/trees/core/gemspec.rb.erb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require '<%= project_name %>/version'
+require 'tasks/config'
+
+<%= project_name.camelize %>::GEM_SPEC = Gem::Specification.new do |spec|
+  proj = Configuration.for('project')
+  spec.name         = proj.name
+  spec.version      = <%= project_name.camelize %>::VERSION
+  
+  spec.author       = proj.author
+  spec.email        = proj.email
+  spec.homepage     = proj.homepage
+  spec.summary      = proj.summary
+  spec.description  = proj.description
+  spec.platform     = Gem::Platform::RUBY
+
+  
+  pkg = Configuration.for('packaging')
+  spec.files        = pkg.files.all
+  spec.executables  = pkg.files.bin.collect { |b| File.basename(b) }
+
+  # add dependencies here
+  # spec.add_dependency("rake", ">= 0.8.1")
+  spec.add_dependency("configuration", ">= 0.0.5")
+
+  if ext_conf = Configuration.for_if_exist?("extension") then
+    spec.extensions << ext_conf.configs
+    spec.extensions.flatten!
+    spec.require_paths << "ext"
+  end
+  
+  if rdoc = Configuration.for_if_exist?('rdoc') then
+    spec.has_rdoc         = true
+    spec.extra_rdoc_files = pkg.files.rdoc
+    spec.rdoc_options     = rdoc.options + [ "--main" , rdoc.main_page ]
+  else
+    spec.has_rdoc         = false
+  end 
+
+  if test = Configuration.for_if_exist?('testing') then
+    spec.test_files       = test.files
+  end 
+
+  if rf = Configuration.for_if_exist?('rubyforge') then
+    spec.rubyforge_project  = rf.project
+  end 
+
+end

data/resources/trees/core/lib/rabal.project.rb.erb

@@ -1,25 +1,57 @@
+#--
+# Copyright (c) <%= Date.today.year %> <%= author %>
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
 module <%= project_name.camelize %>
-    
-    ROOT_DIR        = File.expand_path(File.join(File.dirname(__FILE__),".."))
-    LIB_DIR         = File.join(ROOT_DIR,"lib").freeze
-    RESOURCE_DIR    = File.join(ROOT_DIR,"resources").freeze
 
-    # 
-    # Utility method to require all files ending in .rb in the directory
-    # with the same name as this file minus .rb
-    #
-    def require_all_libs_relative_to(fname)
-        prepend   = File.basename(fname,".rb")
-        search_me = File.join(File.dirname(fname),prepend)
-     
-        Dir.entries(search_me).each do |rb|
-            if File.extname(rb) == ".rb" then
-                require "#{prepend}/#{File.basename(rb,".rb")}"
-            end
-        end
+  # The root directory of the project is considered to be the parent directory
+  # of the 'lib' directory.
+  #   
+  # returns:: [String] The full expanded path of the parent directory of 'lib'
+  #           going up the path from the current file.  Trailing
+  #           File::SEPARATOR is guaranteed.
+  #   
+  def self.root_dir
+    unless @root_dir
+      path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
+      lib_index  = path_parts.rindex("lib")
+      @root_dir = path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
     end 
-    module_function :require_all_libs_relative_to
+    return @root_dir
+  end 
 
-end
+  # returns:: [String] The full expanded path of the +config+ directory
+  #           below _root_dir_.  All parameters passed in are joined onto the
+  #           result.  Trailing File::SEPARATOR is guaranteed if _args_ are
+  #           *not* present.
+  #   
+  def self.config_path(*args)
+    self.sub_path("config", *args)
+  end 
+
+  # returns:: [String] The full expanded path of the +data+ directory below
+  #           _root_dir_.  All parameters passed in are joined onto the 
+  #           result. Trailing File::SEPARATOR is guaranteed if 
+  #           _*args_ are *not* present.
+  #   
+  def self.data_path(*args)
+    self.sub_path("data", *args)
+  end 
 
-<%= project_name.camelize %>.require_all_libs_relative_to(__FILE__)
+  # returns:: [String] The full expanded path of the +lib+ directory below
+  #           _root_dir_.  All parameters passed in are joined onto the 
+  #           result. Trailing File::SEPARATOR is guaranteed if 
+  #           _*args_ are *not* present.
+  #   
+  def self.lib_path(*args)
+    self.sub_path("lib", *args)
+  end 
+
+  def self.sub_path(sub,*args)
+    sp = ::File.join(root_dir, sub) + File::SEPARATOR
+    sp = ::File.join(sp, *args) if args
+  end
+
+end
+require '<%= project_name %>/version'

data/resources/trees/core/lib/rabal.project/version.rb.erb

@@ -1,18 +1,26 @@
+#--
+# Copyright (c) <%= Date.today.year %> <%= author %>
+# All rights reserved.  See LICENSE and/or COPYING for details
+#++
+
 module <%= project_name.camelize %>
-    class Version
-        MAJOR   = 0
-        MINOR   = 0
-        BUILD   = 1
+  module Version
+    MAJOR   = 0
+    MINOR   = 0
+    BUILD   = 1
 
-        class << self
-            def to_a
-                [MAJOR, MINOR, BUILD]
-            end
+    def to_a 
+      [MAJOR, MINOR, BUILD]
+    end
 
-            def to_s
-                to_a.join(".")
-            end
-        end
+    def to_s
+      to_a.join(".")
     end
-    VERSION = Version.to_s
+
+    module_function :to_a
+    module_function :to_s
+
+    STRING = Version.to_s
+  end
+  VERSION = Version.to_s
 end

data/resources/trees/core/tasks/announce.rake.erb

@@ -1,57 +1,39 @@
-#-----------------------------------------------------------------------
-# Announcement tasks
-#   - create a basic email template that can be used to send email to
-#     rubytalk.
-#-----------------------------------------------------------------------
-def changes
-    change_file = File.expand_path(File.join(<%= project_name.camelize %>::ROOT_DIR,"CHANGES"))
-    sections    = File.read(change_file).split(/^(?===)/)
-end
-
-def last_changeset
-    changes[1]
-end
-
-def announcement
-    urls    = "  #{<%= project_name.camelize %>::SPEC.homepage}"
-    subject = "#{<%= project_name.camelize %>::SPEC.name} #{<%= project_name.camelize %>::VERSION} Released"
-    title   = "#{<%= project_name.camelize %>::SPEC.name} version #{<%= project_name.camelize %>::VERSION} has been released."
-    body    = <<BODY
-#{<%= project_name.camelize %>::SPEC.description.rstrip}
-
-{{ Changelog for Version #{<%= project_name.camelize %>::VERSION} }}
-
-#{last_changeset.rstrip}
-
-BODY
-
-    return subject, title, body, urls
-end
+require 'tasks/config'
+#-------------------------------------------------------------------------------
+# announcement methods
+#-------------------------------------------------------------------------------
 
+proj_config = Configuration.for('project')
 namespace :announce do
-    desc "create email for ruby-talk"
-    task :email do
-        subject, title, body, urls = announcement
+  desc "create email for ruby-talk"
+  task :email do
+    info = Utils.announcement
+
+    File.open("email.txt", "w") do |mail|
+      mail.puts "From: #{proj_config.author} <#{proj_config.email}>"
+      mail.puts "To: ruby-talk@ruby-lang.org"
+      mail.puts "Date: #{Time.now.rfc2822}"
+      mail.puts "Subject: [ANN] #{info[:subject]}"
+      mail.puts
+      mail.puts info[:title]
+      mail.puts
+      mail.puts "  gem install #{<%= project_name.camelize %>::GEM_SPEC.name}"
+      mail.puts
+      mail.puts info[:urls]
+      mail.puts 
+      mail.puts info[:description]
+      mail.puts 
+      mail.puts "{{ Release notes for Version #{<%= project_name.camelize %>::VERSION} }}"
+      mail.puts 
+      mail.puts info[:release_notes]
+      mail.puts
+    end 
+    puts "Created the following as email.txt:"
+    puts "-" * 72
+    puts File.read("email.txt")
+    puts "-" * 72
+  end 
+
+  CLOBBER << "email.txt"
+end
 
-        File.open("email.txt", "w") do |mail|
-            mail.puts "From: #{<%= project_name.camelize %>::SPEC.author} <#{<%= project_name.camelize %>::SPEC.email}>"
-            mail.puts "To: ruby-talk@ruby-lang.org"
-            mail.puts "Date: #{Time.now.rfc2822}"
-            mail.puts "Subject: [ANN] #{subject}"
-            mail.puts
-            mail.puts title
-            mail.puts
-            mail.puts urls
-            mail.puts 
-            mail.puts body
-            mail.puts 
-            mail.puts urls
-        end
-        puts "Created the following as email.txt:"
-        puts "-" * 72
-        puts File.read("email.txt")
-        puts "-" * 72
-    end
-    
-    CLOBBER << "email.txt"
-end