hen 0.2.7 → 0.3.2

data/lib/hen/cli.rb

@@ -3,7 +3,7 @@
 #                                                                             #
 # hen -- Just a Rake helper                                                   #
 #                                                                             #
-# Copyright (C) 2007-2008 University of Cologne,                              #
+# Copyright (C) 2007-2011 University of Cologne,                              #
 #                         Albertus-Magnus-Platz,                              #
 #                         50923 Cologne, Germany                              #
 #                                                                             #
@@ -26,60 +26,135 @@
 ###############################################################################
 #++
 
+require 'hen'
+require 'etc'
 require 'erb'
-
-require 'rubygems'
 require 'highline/import'
 
-module Hen::CLI
+class Hen
 
-  # Collect user's answers by key, so we don't have to ask again.
-  @@values = {}
+  # Some helper methods used by the Hen executable. Also available
+  # for use in custom project skeletons.
 
-  alias_method :original_ask, :ask
+  module CLI
 
-  # Ask the user to enter an appropriate value for +key+. Uses
-  # already stored answer if present, unless +cached+ is false.
-  def ask(key, config_key = nil, cached = true, &block)
-    @@values[key] = nil unless cached
+    @answers = {}
 
-    @@values[key] ||= config_key && Hen.config(config_key) ||
-      original_ask("Please enter your #{key}: ", &block)
-  rescue Interrupt
-    abort ''
-  end
+    class << self
 
-  # Same as #ask, but requires a non-empty value to be entered.
-  def ask!(key, config_key = nil, &block)
-    msg = "#{key} is required! Please enter a non-empty value."
-    max = 3
+      # Collect user's answers by key, so we don't have to ask again.
+      attr_reader :answers
 
-    max.times { |i|
-      value = ask(key, config_key, i.zero?, &block)
-      return value unless value.empty?
+    end
 
-      puts msg
-    }
+    # Renders the contents of +sample+ as an ERb template,
+    # storing the result in +target+. Returns the content.
+    def render(sample, target)
+      abort "Sample file not found: #{sample}" unless File.readable?(sample)
 
-    abort "You had #{max} tries -- now be gone!"
-  end
+      if File.readable?(target)
+        abort unless agree("Target file already exists: #{target}. Overwrite? ")
+        FileUtils.cp(target, "#{target}.bak-#{Time.now.to_i}")
+      end
+
+      content = ERB.new(File.read(sample)).result(binding)
+
+      File.open(target, 'w') { |f| f.puts content unless content.empty? }
+
+      content
+    end
+
+    # The project name. (Required)
+    #
+    # Quoting the {Ruby Packaging Standard}[http://chneukirchen.github.com/rps/]:
+    #
+    # Project names SHOULD only contain underscores as separators
+    # in their names.
+    #
+    # If a project is an enhancement, plugin, extension, etc. for
+    # some other project it SHOULD contain a dash in the name
+    # between the original name and the project's name.
+    def progname(default = nil)
+      ask!("Project's name", default)
+    end
+
+    # The project's namespace. (Required)
+    #
+    # Namespaces SHOULD match the project name in SnakeCase.
+    def classname(default = default_classname)
+      ask!("Module's/Class's name", default)
+    end
+
+    # The author's full name. (Required)
+    def fullname(default = default_fullname)
+      ask!('Full name', default)
+    end
+
+    # The author's e-mail address. (Optional, but highly recommended)
+    def emailaddress(default = default_emailaddress)
+      ask('E-mail address', default)
+    end
+
+    # A short one-line summary of the project's description. (Required)
+    def progdesc(default = nil)
+      ask!("Program's description summary", default)
+    end
+
+    private
 
-  # Renders the contents of +sample+ as an ERb template,
-  # storing the result in +target+. Returns the content.
-  def render(sample, target)
-    abort "Sample file not found: #{sample}" unless File.readable?(sample)
+    # Determine a suitable default namespace from the project name.
+    def default_classname
+      pname = progname
+      pname.gsub(/(?:\A|_)(.)/) { $1.upcase } if pname && !pname.empty?
+    end
+
+    # Determine a default name from the global config or, if available,
+    # from the {GECOS field}[http://en.wikipedia.org/wiki/Gecos_field]
+    # in the <tt>/etc/passwd</tt> file.
+    def default_fullname
+      author = Hen.config('gem/author')
+      return author if author && !author.empty?
+
+      pwent = Etc.getpwuid(Process.euid)
+      gecos = pwent.gecos if pwent
+      gecos[/[^,]*/] if gecos && !gecos.empty?
+    end
 
-    if File.readable?(target)
-      abort unless agree("Target file already exists: #{target}. Overwrite? ")
+    # Determine a default e-mail address from the global config.
+    def default_emailaddress
+      email = Hen.config('gem/email')
+      return email if email && !email.empty?
     end
 
-    content = ERB.new(File.read(sample)).result(binding)
+    alias_method :_hen_original_ask, :ask
 
-    File.open(target, 'w') { |f|
-      f.puts content unless content.empty?
-    }
+    # Ask the user to enter an appropriate value for +key+. Uses
+    # already stored answer if present, unless +cached+ is false.
+    def ask(key, default = nil, cached = true)
+      CLI.answers[key] = nil unless cached
+
+      CLI.answers[key] ||= _hen_original_ask("Please enter your #{key}: ") { |q|
+        q.default = default if default
+      }
+    rescue Interrupt
+      abort ''
+    end
+
+    # Same as #ask, but requires a non-empty value to be entered.
+    def ask!(key, default = nil, max = 3)
+      msg = "#{key} is required! Please enter a non-empty value."
+
+      max.times { |i|
+        value = ask(key, default, i.zero?)
+        return value unless value.empty?
+
+        puts msg
+      }
+
+      warn "You had #{max} tries now -- giving up..."
+      ''  # default value
+    end
 
-    content
   end
 
 end

data/lib/hen/dsl.rb

@@ -26,35 +26,35 @@
 ###############################################################################
 #++
 
+require 'hen'
 require 'nuggets/file/which'
 
 class Hen
 
   # Some helper methods for use inside of a Hen definition.
+
   module DSL
 
     extend self
 
     # The Hen configuration.
     def config
-      config = Hen.config
-
-      # always return a duplicate for a value, hence making the
-      # configuration immutable
-      def config.[](key)
-        fetch(key).dup
-      rescue IndexError
-        {}
-      end
-
-      config
+      extend_object(Hen.config.dup) {
+        # Always return a duplicate for a value,
+        # hence making the configuration immutable
+        def [](key)  # :nodoc:
+          fetch(key).dup
+        rescue IndexError
+          {}
+        end
+      }
     end
 
     # Define task +t+, but overwrite any existing task of that name!
-    # (Rake usually just adds them up)
-    def task!(t, &block)
+    # (Rake usually just adds them up.)
+    def task!(t, *args)
       Rake.application.instance_variable_get(:@tasks).delete(t.to_s)
-      task(t, &block)
+      task(t, *args, &block_given? ? Proc.new : nil)
     end
 
     # Find a command that is executable and run it. Intended for
@@ -71,149 +71,256 @@ class Hen
       end
     end
 
-    # Prepare the use of Rubyforge, optionally logging in right away.
-    # Returns the RubyForge object.
-    def init_rubyforge(login = true)
-      require_rubyforge
-
-      rf = RubyForge.new.configure
-      rf.login if login
+    # Clean up the file lists in +args+ by removing duplicates and either
+    # deleting any files that are not managed by the source code management
+    # system (untracked files) or, if the project is not version-controlled
+    # or the SCM is not recognized, deleting any files that don't exist.
+    #
+    # The return value indicates whether source control is in effect.
+    #
+    # Currently supported SCM's (in that order): Git[http://git-scm.com],
+    # SVN[http://subversion.tigris.org].
+    def mangle_files!(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      managed_files = [:git, :svn].find { |scm|
+        res = send(scm) { |scm_obj| scm_obj.managed_files }
+        break res if res
+      } if !options.has_key?(:managed) || options[:managed]
+
+      args.each { |files|
+        files ? files.uniq! : next
+
+        if managed_files
+          files.replace(files & managed_files)
+        else
+          files.delete_if { |file| !File.readable?(file) }
+        end
+      }
 
-      rf
+      !!managed_files
     end
 
-    # Encapsulates tasks targeting at Rubyforge, skipping those if no
-    # Rubyforge project is defined. Yields the Rubyforge configuration
+    # Encapsulates tasks targeting at RubyForge, skipping those if no
+    # RubyForge project is defined. Yields the RubyForge configuration
     # hash and, optionally, a proc to obtain RubyForge objects from (via
-    # +call+; reaching out to init_rubyforge).
-    def rubyforge(&block)
+    # +call+; reaching out to #init_rubyforge).
+    def rubyforge
       rf_config  = config[:rubyforge]
       rf_project = rf_config[:project]
 
-      raise 'Skipping Rubyforge tasks' if rf_project.nil? || rf_project.empty?
+      if rf_project && !rf_project.empty? && have_rubyforge?
+        rf_config[:package] ||= rf_project
 
-      require_rubyforge
+        call_block(Proc.new, rf_config) { |*args|
+          init_rubyforge(args.empty? || args.first)
+        }
+      else
+        skipping 'RubyForge'
+      end
+    end
 
-      raise LocalJumpError, 'no block given' unless block
+    # Encapsulates tasks targeting at RubyGems.org, skipping those if
+    # RubyGem's 'push' command is not available. Yields an optional
+    # proc to obtain RubyGems (pseudo-)objects from (via +call+;
+    # reaching out to #init_rubygems).
+    def rubygems
+      if have_rubygems?
+        call_block(Proc.new) { |*args| init_rubygems }
+      else
+        skipping 'RubyGems'
+      end
+    end
 
-      block_args = [rf_config]
-      block_args << lambda { |*args|
-        init_rubyforge(args.empty? || args.first)
-      } if block.arity > 1
+    # DEPRECATED: Use #rubygems instead.
+    def gemcutter
+      warn "#{self}#gemcutter is deprecated; use `rubygems' instead."
+      rubygems(&block_given? ? Proc.new : nil)
+    end
 
-      block[*block_args]
+    # Encapsulates tasks targeting at Git, skipping those if the current
+    # project us not controlled by Git. Yields a Git object via #init_git.
+    def git
+      have_git? ? yield(init_git) : skipping('Git')
     end
 
-    # Prepare the use of Gemcutter. Returns the Gemcutter (pseudo-)object.
-    def init_gemcutter
-      require_gemcutter(false)
+    # Encapsulates tasks targeting at SVN, skipping those if the current
+    # project us not controlled by SVN. Yields an SVN object via #init_svn.
+    def svn
+      have_svn? ? yield(init_svn) : skipping('SVN')
+    end
 
-      gc = Object.new
+    private
 
-      def gc.push(gem)
-        Gem::CommandManager.instance.run(['push', gem])
+    # Warn about skipping tasks for +name+ (if +do_warn+ is true) and return nil.
+    def skipping(name, do_warn = Hen.verbose)
+      warn "Skipping #{name} tasks." if do_warn
+      nil
+    end
+
+    # Warn about missing library +lib+ (if +do_warn+ is true) and return false.
+    def missing_lib(lib, do_warn = $DEBUG)
+      warn "Please install the `#{lib}' library for additional tasks." if do_warn
+      false
+    end
+
+    # Loads the RubyForge library, giving a
+    # nicer error message if it's not found.
+    def have_rubyforge?
+      require 'rubyforge'
+      true
+    rescue LoadError
+      missing_lib 'rubyforge'
+    end
+
+    # Loads the RubyGems +push+ command, giving
+    # a nicer error message if it's not found.
+    def have_rubygems?
+      begin
+        require 'rubygems/command_manager'
+        require 'rubygems/commands/push_command'
+      rescue LoadError
+        # rubygems < 1.3.6, gemcutter < 0.4.0
+        require 'commands/abstract_command'
+        require 'commands/push'
       end
 
-      gc
+      Gem::Commands::PushCommand
+    rescue LoadError, NameError
+      missing_lib 'gemcutter'
+    end
+
+    # Checks whether the current project is managed by Git.
+    def have_git?
+      File.directory?('.git')
     end
 
-    # Encapsulates tasks targeting at Gemcutter, skipping those if
-    # Gemcutter's 'push' command is not available. Yields an optional
-    # proc to obtain Gemcutter objects from (via +call+; reaching out
-    # to init_gemcutter).
-    def gemcutter(&block)
-      raise 'Skipping Gemcutter tasks' unless require_gemcutter
+    # Checks whether the current project is managed by SVN.
+    def have_svn?
+      File.directory?('.svn')
+    end
 
-      raise LocalJumpError, 'no block given' unless block
+    # Prepare the use of RubyForge, optionally logging
+    # in right away. Returns the RubyForge object.
+    def init_rubyforge(login = true)
+      return unless have_rubyforge?
 
-      block_args = []
-      block_args << lambda { |*args|
-        init_gemcutter
-      } if block.arity > 0
+      rf = RubyForge.new.configure
+      rf.login if login
 
-      block[*block_args]
+      rf
     end
 
-    def git
-      raise 'Skipping Git tasks' unless File.directory?('.git')
+    # Prepare the use of RubyGems.org. Returns the RubyGems
+    # (pseudo-)object.
+    def init_rubygems
+      pseudo_object {
+        def method_missing(cmd, *args)  # :nodoc:
+          run(cmd, *args)
+        end
 
-      yield init_git
+        def run(cmd, *args)  # :nodoc:
+          Gem::CommandManager.instance.run([cmd.to_s.tr('_', '-'), *args])
+        end
+      } if have_rubygems?
     end
 
+    # Prepare the use of Git. Returns the Git (pseudo-)object.
     def init_git
-      class << git = Object.new
+      pseudo_object {
+        def method_missing(cmd, *args)  # :nodoc:
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          options[:verbose] = Hen.verbose unless options.has_key?(:verbose)
 
-        instance_methods.each { |method|
-          undef_method(method) unless method =~ /\A__/
-        }
-
-        def method_missing(cmd, *args)
-          sh 'git', cmd.to_s.tr('_', '-'), *args
+          sh('git', cmd.to_s.tr('_', '-'), *args << options)
         end
 
-        #alias_method :sh, :system
-
-        def run(*args)
-          %x{#{args.unshift('git').join(' ')}}
+        def run(cmd, *args)  # :nodoc:
+          %x{git #{args.unshift(cmd.to_s.tr('_', '-')).join(' ')}}
         end
 
-        def remote_for_branch(branch)
-          run(:branch, '-r')[/(\S+)\/#{Regexp.escape(branch)}$/, 1]
+        def remote_for_branch(branch)  # :nodoc:
+          run(:branch, '-r')[%r{(\S+)/#{Regexp.escape(branch)}$}, 1]
         end
 
-        def url_for_remote(remote)
-          run(:remote, '-v')[/\A#{Regexp.escape(remote)}\s+(\S+)/, 1]
+        def url_for_remote(remote)  # :nodoc:
+          run(:remote, '-v')[%r{\A#{Regexp.escape(remote)}\s+(\S+)}, 1]
         end
 
-        def find_remote(regexp)
+        def find_remote(regexp)  # :nodoc:
           run(:remote, '-v').split($/).grep(regexp).first
         end
 
-        def easy_clone(url, dir = '.', remote = 'origin')
+        def easy_clone(url, dir = '.', remote = 'origin')  # :nodoc:
           clone '-n', '-o', remote, url, dir
         end
 
-        def checkout_remote_branch(remote, branch = 'master')
+        def checkout_remote_branch(remote, branch = 'master')  # :nodoc:
           checkout '-b', branch, "#{remote}/#{branch}"
         end
 
-        def add_and_commit(msg)
+        def add_and_commit(msg)  # :nodoc:
           add '.'
           commit '-m', msg
         end
 
-      end
+        def managed_files  # :nodoc:
+          run(:ls_files).split($/)
+        end
+      } if have_git?
+    end
+
+    # Prepare the use of SVN. Returns the SVN (pseudo-)object.
+    def init_svn
+      pseudo_object {
+        def method_missing(cmd, *args)  # :nodoc:
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          options[:verbose] = Hen.verbose unless options.has_key?(:verbose)
 
-      git
+          sh('svn', cmd.to_s.tr('_', '-'), *args << options)
+        end
+
+        def run(cmd, *args)  # :nodoc:
+          %x{svn #{args.unshift(cmd.to_s.tr('_', '-')).join(' ')}}
+        end
+
+        def version  # :nodoc:
+          %x{svnversion}[/\d+/]
+        end
+
+        def managed_files  # :nodoc:
+          run(:list, '--recursive').split($/)
+        end
+      } if have_svn?
     end
 
-    private
+    # Extend +object+ with given +blocks+.
+    def extend_object(object, *blocks)
+      blocks << Proc.new if block_given?
 
-    # Loads the Rubyforge library, giving a
-    # nicer error message if it's not found.
-    def require_rubyforge
-      begin
-        require 'rubyforge'
-      rescue LoadError
-        raise "Please install the `rubyforge' gem first."
-      end
+      singleton_class = class << object; self; end
+
+      blocks.compact.reverse_each { |block|
+        singleton_class.class_eval(&block)
+      }
+
+      object
     end
 
-    # Loads the Gemcutter 'push' command, giving
-    # a nicer error message if it's not found.
-    def require_gemcutter(relax = true)
-      begin
-        require 'rubygems/command_manager'
-        require 'rubygems/commands/push_command'
-      rescue LoadError
-        # rubygems < 1.3.6, gemcutter < 0.4.0
-        require 'commands/abstract_command'
-        require 'commands/push'
-      end
+    # Create a (pseudo-)object.
+    def pseudo_object
+      extend_object(Object.new, block_given? ? Proc.new : nil) {
+        instance_methods.each { |method|
+          undef_method(method) unless method =~ /\A__/
+        }
+      }
+    end
 
-      Gem::Commands::PushCommand
-    rescue LoadError, NameError
-      raise "Please install the `gemcutter' gem first." unless relax
+    # Calls block +block+ with +args+, appending an
+    # optional passed block if requested by +block+.
+    def call_block(block, *args)
+      args << Proc.new if block.arity > args.size
+      block[*args]
     end
 
   end