blackwinter-hen 0.1.5

data/lib/hen.rb

@@ -0,0 +1,305 @@
+#--
+###############################################################################
+#                                                                             #
+# hen -- Just a Rake helper                                                   #
+#                                                                             #
+# Copyright (C) 2007-2008 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50932 Cologne, Germany                              #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# hen is free software; you can redistribute it and/or modify it under the    #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# hen is distributed in the hope that it will be useful, but WITHOUT ANY      #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with hen. If not, see <http://www.gnu.org/licenses/>.                       #
+#                                                                             #
+###############################################################################
+#++
+
+require 'yaml'
+require 'forwardable'
+
+require 'rubygems'
+require 'rake'
+require 'nuggets/env/user_home'
+require 'nuggets/proc/bind'
+
+require 'hen/dsl'
+require 'hen/version'
+
+class Hen
+
+  # The directories which contain the hen files
+  HENDIRS = [File.join(File.dirname(__FILE__), 'hens')] +
+            (ENV['HENPATH'] || '').split(File::PATH_SEPARATOR)
+
+  # All hens found, mapped by their name
+  HENS = Dir[*HENDIRS.map { |d| "#{d}/*.rake" }].uniq.inject(
+    Hash.new { |h, k| h[k] = [] }
+  ) { |hash, hen|
+    hash[File.basename(hen, '.rake')] << hen; hash
+  }
+
+  # Directories to search for .henrc
+  RCDIRS = ['.', ENV.user_home]
+
+  # A container for all loaded hens
+  @hens = {}
+
+  # The verbosity concerning errors and warnings
+  @verbose = true
+
+  class << self
+
+    attr_reader :hens, :verbose
+
+    # call-seq:
+    #   lay!
+    #   lay!(:some_hen, :some_other_hen)
+    #   lay!(:exclude => [:some_hen, :some_other_hen])
+    #
+    # Loads the hens, causing them to lay their eggs^H^H^Htasks. Either all,
+    # if no restrictions are specified, or the given hens, or all but those
+    # given in the <tt>:exclude</tt> option.
+    def lay!(*args)
+      # Extract potential options hash
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      @verbose = options[:verbose] if options.has_key?(:verbose)
+
+      if block_given?
+        yield.each { |key, value|
+          config[key].update(value)
+        }
+      end
+
+      # Handle include/exclude requirements
+      excl = options[:exclude]
+      args, default = args.empty? ? [excl ? [*excl] : [], true] : [args, false]
+
+      inclexcl = Hash.new(default)
+      args.each { |arg|
+        inclexcl[arg.to_s] = !default
+      }
+
+      # Load all available hens (as far as the
+      # include/exclude conditions are met)
+      load_hens { |hen|
+        inclexcl[hen]
+      }
+
+      # Execute each hen definition
+      hens.each { |name, hen|
+        # Load any dependencies, in case they're not included yet
+        begin
+          load_hens(*hen.dependencies)
+        rescue LoadError => err
+          warn "#{name}: Required dependency missing: " <<
+               File.basename(err.to_s, '.rake') if verbose
+          next
+        end
+
+        hen.lay!
+      }
+    end
+
+    # call-seq:
+    #  add_hen(hen, overwrite = false)
+    #
+    # Adds +hen+ to the global container. Overwrites
+    # an existing hen only if +overwrite+ is true.
+    def add_hen(hen, overwrite = false)
+      if overwrite
+        @hens[hen.name]   = hen
+      else
+        @hens[hen.name] ||= hen
+      end
+    end
+
+    # call-seq:
+    #   Hen[hen] => aHen
+    #
+    # Get hen by name.
+    def [](hen)
+      @hens[hen]
+    end
+
+    # call-seq:
+    #   henrc => aString
+    #
+    # The path to the user's .henrc
+    def henrc(location_only = false)
+      @henrc ||= find_henrc(location_only)
+    end
+
+    # call-seq:
+    #   config => aHash
+    #   config(key) => aValue
+    #
+    # The configuration resulting from the user's .henrc. Takes optional
+    # +key+ argument as "path" into the config hash, returning the thusly
+    # retrieved value.
+    #
+    # Example:
+    #   config('a/b/c')  #=> @config[:a][:b][:c]
+    def config(key = nil)
+      @config ||= YAML.load_file(henrc)
+      return @config unless key
+
+      key.split('/').inject(@config) { |value, k|
+        value.fetch(k.to_sym)
+      }
+    rescue IndexError, NoMethodError
+    end
+
+    private
+
+    # call-seq:
+    #   find_henrc(location_only = false) => aString
+    #
+    # Search for a readable .henrc, or, if +location_only+ is true, just return
+    # a suitable default location.
+    def find_henrc(location_only = false)
+      return ENV['HENRC'] || File.join(RCDIRS.last, '.henrc') if location_only
+
+      if    henrc = ENV['HENRC']
+        abort "The specified .henrc file could not be found: #{henrc}" \
+          unless File.readable?(henrc)
+      elsif henrc = RCDIRS.find { |dir|
+        h = File.join(dir, '.henrc')
+        break h if File.readable?(h)
+      }
+      else
+        abort "No .henrc file could be found! Please " <<
+              "create one first by running 'hen config'."
+      end
+
+      henrc
+    end
+
+    # call-seq:
+    #   load_hens(*hens)
+    #   load_hens(*hens) { |hen_name| ... }
+    #
+    # Actually loads the hen files for +hens+, or all available if none are
+    # specified. If a block is given, only those hen files are loaded for
+    # which the block evaluates to true.
+    def load_hens(*hens, &block)
+      # By default, include all
+      block ||= lambda { |_| true }
+
+      (hens.empty? ? HENS.keys : hens).each { |hen|
+        hen = hen.to_s
+        next unless block[hen]
+
+        HENS[hen].each { |h| load h }
+      }
+    end
+
+  end
+
+  extend Forwardable
+
+  # Forward to the class
+  def_delegators self, :verbose
+
+  attr_reader :name, :dependencies, :block
+
+  # call-seq:
+  #   new(args, overwrite = false) { ... }
+  #
+  # Creates a new Hen instance of a certain name and optional
+  # dependencies; see #resolve_args for details on the +args+
+  # argument. Requires a definition block; see #lay! for details.
+  #
+  # Adds itself to the global hen container via add_hen.
+  def initialize(args, overwrite = false, &block)
+    @name, @dependencies = resolve_args(args)
+
+    unless @block = block
+      raise LocalJumpError, "#{@name}: no block given" if verbose
+      return
+    end
+
+    self.class.add_hen(self, overwrite)
+  end
+
+  # call-seq:
+  #   hen.lay!
+  #
+  # Runs the definition block, exposing helper methods from the DSL.
+  def lay!
+    return if laid?
+
+    # Call dependencies first
+    dependencies.each { |hen|
+      self.class[hen].lay!
+    }
+
+    block.bind(DSL).call
+  rescue => err
+    warn "#{name}: #{err} (#{err.class})" if verbose
+  end
+
+  private
+
+  # call-seq:
+  #   resolve_args(args) => [name, dependencies]
+  #
+  # Splits into hen name and optional dependencies: +args+ may be a single
+  # symbol (or string), or a hash with a single key pointing to a list of
+  # hens this one depends upon.
+  def resolve_args(args)
+    name, dependencies = case args
+      when Hash
+        raise ArgumentError, "Too many hen names: #{args.keys.join(' ')}" \
+          if args.size > 1
+        raise ArgumentError, 'No hen name given' \
+          if args.size < 1
+
+        [args.keys.first, [*args.values.first]]
+      else
+        [args, []]
+    end
+
+    [name.to_sym, dependencies.map { |d| d.to_sym }]
+  end
+
+  # call-seq:
+  #   laid? => true or false
+  #
+  # Keeps track of whether the block has already been executed.
+  def laid?
+    return @laid if @laid
+
+    @laid = true
+    false
+  end
+
+end
+
+# call-seq:
+#   Hen(args) { ... }
+#
+# Just forwards to Hen.new.
+def Hen(args, &block)
+  Hen.new(args, &block)
+end
+
+# call-seq:
+#   Hen!(args) { ... }
+#
+# Same as above, but overwrites any existing hen with the same name.
+def Hen!(args, &block)
+  Hen.new(args, true, &block)
+end

data/lib/hens/gem.rake

@@ -0,0 +1,129 @@
+Hen :gem => :rdoc do
+  # Dependencies:
+  # * rdoc -- Uses RDOC_OPTIONS and 'publish_docs' task
+
+  require 'rake/gempackagetask'
+
+  gem_options = config[:gem]
+  rf_config   = config[:rubyforge]
+
+  if Object.const_defined?(:RDOC_OPTIONS)
+    gem_options[:rdoc_options] ||= RDOC_OPTIONS[:options]
+    rdoc_files                   = RDOC_OPTIONS[:rdoc_files]
+  end
+
+  gem_spec = Gem::Specification.new { |spec|
+
+    ### name
+
+    gem_options[:name] ||= rf_config[:package]
+
+    abort 'Gem name missing' unless gem_options[:name]
+
+    ### version
+
+    abort 'Gem version missing' unless gem_options[:version]
+
+    if gem_options.delete(:append_svnversion) && svnversion = `svnversion`[/\d+/]
+      gem_options[:version] << '.' << svnversion
+    end
+
+    ### author(s)
+
+    if author = gem_options.delete(:author)
+      gem_options[:authors] ||= [author]
+    end
+
+    ### description
+
+    gem_options[:description] ||= gem_options[:summary]
+
+    ### rubyforge project, homepage
+
+    gem_options[:rubyforge_project] ||= rf_config[:project]
+
+    if rf_project = gem_options[:rubyforge_project]
+      rdoc_dir = rf_config[:rdoc_dir] == :package ?
+        rf_config[:package] || gem_options[:name] : RDOC_OPTIONS[:rdoc_dir]
+
+      gem_options[:homepage] ||= "#{rf_project}.rubyforge.org/#{rdoc_dir}"
+    end
+
+    if gem_options[:homepage] && gem_options[:homepage] !~ %r{://}
+      gem_options[:homepage] = 'http://' << gem_options[:homepage]
+    end
+
+    ### extra_rdoc_files, files, executables, bindir
+
+    gem_options[:files]            ||= []
+    gem_options[:extra_rdoc_files] ||= rdoc_files - gem_options[:files] if rdoc_files
+    gem_options[:files]             += gem_options.delete(:extra_files) || []
+
+    gem_options[:executables] ||= gem_options[:files].grep(/\Abin\//)
+
+    [:extra_rdoc_files, :files, :executables].each { |files|
+      gem_options[files].delete_if { |file| !File.exists?(file) }
+    }
+
+    unless gem_options[:executables].empty?
+      gem_options[:bindir] ||= File.dirname(gem_options[:executables].first)
+      gem_options[:executables].map! { |executable| File.basename(executable) }
+    end
+
+    ### dependencies
+
+    (gem_options.delete(:dependencies) || []).each { |dependency|
+      spec.add_dependency(*dependency)
+    }
+
+    ### => set options!
+
+    gem_options.each { |option, value|
+      spec.send("#{option}=", value)
+    }
+  }
+
+  desc 'Display the gem specification'
+  task :gemspec do
+    puts gem_spec.to_ruby
+  end
+
+  desc "Update (or create) the project's gemspec file"
+  task 'gemspec:update' do
+    file = "#{gem_spec.name}.gemspec"
+    action = File.exists?(file) ? 'Updated' : 'Created'
+
+    File.open(file, 'w') { |f| f.puts gem_spec.to_ruby }
+
+    puts "#{action} #{file}"
+  end
+
+  pkg_task = Rake::GemPackageTask.new(gem_spec) do |pkg|
+    pkg.need_tar_gz = true
+    pkg.need_zip    = true
+  end
+
+  rubyforge do |rf_config, rf_pool|
+
+    desc 'Package and upload the release to Rubyforge'
+    task :release => [:package, :publish_docs] do
+      files = Dir[File.join('pkg', "#{pkg_task.package_name}.*")]
+      abort 'Nothing to release!' if files.empty?
+
+      # shorten to (at most) three digits
+      version = pkg_task.version.to_s.split(/([.])/)[0..4].join
+
+      rf = rf_pool.call
+
+      # TODO: Add release notes and changes.
+      #uc = rf.userconfig
+      #uc['release_notes']   = description if description
+      #uc['release_changes'] = changes if changes
+      #uc['preformatted']    = true
+
+      rf.add_release rf_config[:project], pkg_task.name, version, *files
+    end
+
+  end
+
+end

data/lib/hens/rdoc.rake

@@ -0,0 +1,79 @@
+Hen :rdoc do
+
+  require 'rake/rdoctask'
+
+  rdoc_options = config[:rdoc]
+
+  if rf_package = config[:rubyforge][:package]
+    rdoc_options[:title] ||= "#{rf_package} Application documentation"
+  end
+
+  ### rdoc_dir
+
+  rdoc_dir = rdoc_options.delete(:rdoc_dir)
+
+  ### rdoc_files
+
+  rdoc_files = FileList[rdoc_options.delete(:rdoc_files)].
+    sort.uniq.select { |file| File.exists?(file) }
+
+  ### rdoc_options
+
+  rdoc_options.delete(:main) unless rdoc_files.include?(rdoc_options[:main])
+
+  rdoc_options = rdoc_options.map { |option, value|
+    option = '--' << option.to_s.tr('_', '-')
+    value.is_a?(String) ? [option, value] : value ? option : nil
+  }.compact.flatten
+
+  # Make settings available to other hens
+  RDOC_OPTIONS = {
+    :rdoc_dir   => rdoc_dir,
+    :rdoc_files => rdoc_files,
+    :options    => rdoc_options
+  }
+
+  unless rdoc_files.empty?
+    rdoc_task = Rake::RDocTask.new(:doc) { |rdoc|
+      rdoc.rdoc_dir   = rdoc_dir
+      rdoc.rdoc_files = rdoc_files
+      rdoc.options    = rdoc_options
+    }
+  else
+    task :doc do
+      warn 'No files to generate documentation for!'
+    end
+  end
+
+  rubyforge do |rf_config|
+
+    desc 'Publish RDoc to Rubyforge'
+    task :publish_docs => :doc do
+      rf_project = rf_config[:project]
+      abort 'Rubyforge project name missing' unless rf_project
+
+      rf_user = rf_config[:username]
+      abort 'Rubyforge user name missing' unless rf_user
+
+      rf_host = "#{rf_user}@rubyforge.org"
+
+      local_dir  = rdoc_task.rdoc_dir
+      remote_dir = "/var/www/gforge-projects/#{rf_project}"
+
+      if rdoc_dir = rf_config[:rdoc_dir]
+        if rf_package = rf_config[:package]
+          rdoc_dir = rf_package if rdoc_dir == :package
+        end
+
+        remote_dir = File.join(remote_dir, rdoc_dir)
+      end
+
+      execute(
+        "rsync -av --delete #{local_dir}/ #{rf_host}:#{remote_dir}/",
+        "scp -r #{local_dir}/ #{rf_host}:#{remote_dir}/"
+      )
+    end
+
+  end
+
+end

data/lib/hens/spec.rake

@@ -0,0 +1,36 @@
+Hen :spec do
+
+  require 'spec/rake/spectask'
+
+  spec_options = config[:spec]
+
+  spec_files = spec_options.delete(:files) || FileList[spec_options.delete(:pattern)]
+
+  if spec_files && !spec_files.empty?
+    if spec_helper = spec_options.delete(:helper) and File.readable?(spec_helper)
+      spec_files.delete(spec_helper)
+      spec_files.unshift(spec_helper)
+    end
+
+    spec_opts = spec_options.map { |option, value|
+      option = '--' << option.to_s.tr('_', '-')
+      value.is_a?(String) ? [option, value] : value ? option : nil
+    }.compact.flatten
+
+    spec_task = lambda { |t|
+      t.spec_files = spec_files
+      t.spec_opts  = spec_opts
+    }
+
+    Spec::Rake::SpecTask.new(&spec_task)
+
+    #desc "Run specs with RCov"
+    Spec::Rake::SpecTask.new('spec:rcov') do |t|
+      spec_task[t]
+
+      t.rcov = true
+      t.rcov_opts = ['--exclude', spec_files.join(',')]
+    end
+  end
+
+end

data/lib/hens/test.rake

@@ -0,0 +1,19 @@
+Hen :test do
+
+  require 'rake/testtask'
+
+  test_options = config[:test]
+
+  test_files = test_options.delete(:files) || FileList[test_options.delete(:pattern)]
+
+  if test_files && !test_files.empty?
+    Rake::TestTask.new { |t|
+      t.test_files = test_files
+
+      test_options.each { |option, value|
+        t.send("#{option}=", value)
+      }
+    }
+  end
+
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: blackwinter-hen
+version: !ruby/object:Gem::Version 
+  version: 0.1.5
+platform: ruby
+authors: 
+- Jens Wille
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-22 00:00:00 -08:00
+default_executable: hen
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-nuggets
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.3
+    version: 
+description: Hoe or Echoe? No, thanks! Just a Rake helper that fits my own personal style.
+email: jens.wille@uni-koeln.de
+executables: 
+- hen
+extensions: []
+
+extra_rdoc_files: 
+- COPYING
+- ChangeLog
+- README
+files: 
+- lib/hen.rb
+- lib/hen/cli.rb
+- lib/hen/dsl.rb
+- lib/hen/version.rb
+- bin/hen
+- Rakefile
+- COPYING
+- ChangeLog
+- README
+- lib/hens/rdoc.rake
+- lib/hens/gem.rake
+- lib/hens/test.rake
+- lib/hens/spec.rake
+- example/hens
+- example/hens/sample.rake
+- example/project
+- example/project/Rakefile
+- example/project/COPYING
+- example/project/ChangeLog
+- example/project/lib
+- example/project/lib/__progname__
+- example/project/lib/__progname__/version.rb
+- example/project/lib/__progname__.rb
+- example/project/README
+- example/.henrc
+has_rdoc: true
+homepage: http://prometheus.rubyforge.org/hen
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --title
+- hen Application documentation
+- --charset
+- UTF-8
+- --main
+- README
+- --all
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: prometheus
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Hoe or Echoe? No, thanks! Just a Rake helper that fits my own personal style.
+test_files: []
+