Skip to content

Commit

Permalink
update to fixme tasks
Browse files Browse the repository at this point in the history
  • Loading branch information
@copiousfreetime
copiousfreetime committed Mar 13, 2013
1 parent 4514ac0 commit af263f5
Show file tree
Hide file tree
Showing 4 changed files with 516 additions and 546 deletions.
345 changes: 8 additions & 337 deletions Rakefile
View file
@@ -1,349 +1,20 @@
# vim: syntax=ruby
load 'tasks/this.rb'

This.name = "amalgalite"
This.author = "Jeremy Hinegardner"
This.email = "jeremy@copiousfreetime.org"
This.homepage = "http://github.com/copiousfreetime/#{ This.name }"
This.version = Util.version

#------------------------------------------------------------------------------
# If you want to Develop on this project just run 'rake develop' and you'll
# have all you need to get going. If you want to use bundler for development,
# then run 'rake develop:using_bundler'
#------------------------------------------------------------------------------
namespace :develop do

# Install all the development and runtime dependencies of this gem using the
# gemspec.
task :default do
require 'rubygems/dependency_installer'
installer = Gem::DependencyInstaller.new

# list these here instead of gem dependencies since there is not a way to
# specify ruby version specific dependencies
if RUBY_VERSION < "1.9.2"
Util.platform_gemspec.add_development_dependency( 'rcov', '~> 1.0.0' )
else
Util.platform_gemspec.add_development_dependency( 'simplecov', '~> 0.6.4' )
end

puts "Installing gem depedencies needed for development"
Util.platform_gemspec.dependencies.each do |dep|
if dep.matching_specs.empty? then
puts "Installing : #{dep}"
installer.install dep
else
puts "Skipping : #{dep} -> already installed #{dep.matching_specs.first.full_name}"
end
end
puts "\n\nNow run 'rake test'"
end

# Create a Gemfile that just references the gemspec
file 'Gemfile' => :gemspec do
File.open( "Gemfile", "w+" ) do |f|
f.puts 'source :rubygems'
f.puts 'gemspec'
end
end

desc "Create a bundler Gemfile"
task :using_bundler => 'Gemfile' do
puts "Now you can 'bundle'"
end

# Gemfiles are build artifacts
CLOBBER << FileList['Gemfile*']
end
desc "Boostrap development"
task :develop => "develop:default"

#------------------------------------------------------------------------------
# RSpec - standard RSpec rake task
#------------------------------------------------------------------------------
begin
require 'rspec/core/rake_task'
RSpec::Core::RakeTask.new( :test ) do |t|
t.ruby_opts = %w[ -w ]
t.rspec_opts = %w[ --color ]
# t.rspec_opts.concat %w[ --format documentation ]
end
task :default => :test
rescue LoadError
Util.task_warning( 'test' )
end

#------------------------------------------------------------------------------
# RDoc - standard rdoc rake task, although we must make sure to use a more
# recent version of rdoc since it is the one that has 'tomdoc' markup
#------------------------------------------------------------------------------
begin
gem 'rdoc' # otherwise we get the wrong task from stdlib
require 'rdoc/task'
RDoc::Task.new do |t|
t.markup = 'tomdoc'
t.rdoc_dir = 'doc'
t.main = 'README.rdoc'
t.title = "#{This.name} #{This.version}"
t.rdoc_files.include( '*.rdoc', 'lib/**/*.rb' )
end
rescue LoadError => le
Util.task_warning( 'rdoc' )
end

#------------------------------------------------------------------------------
# Coverage - optional code coverage, rcov for 1.8 and simplecov for 1.9, so
# for the moment only rcov is listed.
#------------------------------------------------------------------------------
if RUBY_VERSION <= "1.9.2"
begin
require 'rcov/rcovtask'
Rcov::RcovTask.new( 'coverage' ) do |t|
t.libs << 'spec'
t.pattern = 'spec/**/*_spec.rb'
t.verbose = true
t.rcov_opts << "-x ^/" # remove all the global files
t.rcov_opts << "--sort coverage" # so we see the worst files at the top
end
rescue LoadError
Util.task_warning( 'rcov' )
end
else
begin
require 'simplecov'
desc 'Run tests with code coverage'
task :coverage do
ENV['COVERAGE'] = 'true'
Rake::Task[:test].execute
end
CLOBBER << FileList["coverage"]
rescue LoadError
Util.task_warning( 'simplecov' )
end
end

#------------------------------------------------------------------------------
# Manifest - We want an explicit list of thos files that are to be packaged in
# the gem. Most of this is from Hoe.
#------------------------------------------------------------------------------
namespace 'manifest' do
desc "Check the manifest"
task :check => :clean do
files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
files = files.select{ |f| File.file?( f ) }

tmp = "Manifest.tmp"
File.open( tmp, 'w' ) do |f|
f.puts files.join("\n")
end

begin
sh "diff -du Manifest.txt #{tmp}"
ensure
rm tmp
end
puts "Manifest looks good"
end

desc "Generate the manifest"
task :generate => :clean do
files = %x[ git ls-files ].split("\n").sort
files.reject! { |f| f =~ This.exclude_from_manifest }
File.open( "Manifest.txt", "w" ) do |f|
f.puts files.join("\n")
end
end
end

#------------------------------------------------------------------------------
# Fixme - look for fixmes and report them
#------------------------------------------------------------------------------
task :fixme => 'manifest:check' do
Util.read_manifest.each do |file|
next if file == File.basename( __FILE__ )

puts "FIXME: Rename #{file}" if file =~ /fixme/i

IO.readlines( file ).each_with_index do |line, idx|
prefix = "FIXME: #{file}:#{idx+1}".ljust(42)
puts "#{prefix} => #{line.strip}" if line =~ /fixme/i
end
end
end

#------------------------------------------------------------------------------
# Gem Specification
#------------------------------------------------------------------------------
This.gemspec = Hash.new
This.gemspec['ruby'] = Gem::Specification.new do |spec|
spec.name = This.name
spec.version = This.version
spec.author = This.author
spec.email = This.email
spec.homepage = This.homepage

spec.summary = This.summary
spec.description = This.description

spec.files = This.manifest
spec.executables = spec.files.grep(/^bin/) { |f| File.basename(f) }
spec.test_files = spec.files.grep(/^spec/)

spec.extra_rdoc_files += spec.files.grep(/(txt|rdoc)$/)
spec.rdoc_options = [ "--main" , 'README.rdoc', ]

# The Runtime Dependencies
# FIXME
# spec.add_dependency( 'map', '~> 6.2.0')
This.ruby_gemspec do |spec|
spec.add_dependency( 'arrayfields', '~> 4.7.4' )
spec.add_dependency( 'fastercsv' , '~> 1.5.5' )

# The Development Dependencies
spec.add_development_dependency("rake" , "~> 0.9.2.2")
spec.add_development_dependency("rspec" , "~> 2.11.0" )
spec.add_development_dependency('zip' , "~> 2.0.2" )
spec.add_development_dependency('rdoc' , '~> 3.12' )
spec.add_development_dependency('rake-compiler', '~> 0.8.1' )

spec.extensions.concat Util.extension_conf_files
spec.add_development_dependency( 'rspec' , '~> 2.13.0')
spec.add_development_dependency( 'rake' , '~> 10.0.3')
spec.add_development_dependency( 'rake-compiler', '~> 0.8.1' )
spec.add_development_dependency( 'rdoc' , '~> 4.0' )
spec.add_development_dependency( 'zip' , "~> 2.0.2" )
end


# The name of the gemspec file on disk
This.gemspec_file = "#{This.name}.gemspec"

# Really this is only here to support those who use bundler
desc "Build the #{This.name}.gemspec file"
task :gemspec do
File.open( This.gemspec_file, "wb+" ) do |f|
f.write Util.platform_gemspec.to_ruby
end
end

# the gemspec is also a dev artifact and should not be kept around.
CLOBBER << This.gemspec_file
CLOBBER << "tmp"

# The standard gem packaging task, everyone has it.
require 'rubygems/package_task'
Gem::PackageTask.new( Util.platform_gemspec ) do
# nothing
end

#------------------------------------------------------------------------------
# Release - the steps we go through to do a final release, this is pulled from
# a compbination of mojombo's rakegem, hoe and hoe-git
#
# 1) make sure we are on the master branch
# 2) make sure there are no uncommitted items
# 3) check the manifest and make sure all looks good
# 4) build the gem
# 5) do an empty commit to have the commit message of the version
# 6) tag that commit as the version
# 7) push master
# 8) push the tag
# 7) pus the gem
#------------------------------------------------------------------------------
task :release_check do
unless `git branch` =~ /^\* master$/
abort "You must be on the master branch to release!"
end
unless `git status` =~ /^nothing to commit/m
abort "Nope, sorry, you have unfinished business"
end
end

desc "Create tag v#{This.version}, build and push #{Util.platform_gemspec.full_name} to rubygems.org"
task :release => [ :release_check, 'manifest:check', :gem ] do
sh "git commit --allow-empty -a -m 'Release #{This.version}'"
sh "git tag -a -m 'v#{This.version}' v#{This.version}"
sh "git push origin master"
sh "git push origin v#{This.version}"
sh "gem push pkg/#{Util.platform_gemspec.full_name}.gem"
end

#------------------------------------------------------------------------------
# Load the extra tasks
#------------------------------------------------------------------------------
load 'tasks/extension.rake'

#------------------------------------------------------------------------------
# Rakefile Support - This is all the guts and utility methods that are
# necessary to support the above tasks.
#
# Lots of Credit for this Rakefile goes to:
#
# Ara T. Howard - see the Rakefile in all of his projects -
# https://github.com/ahoward/
# Tom Preston Werner - his Rakegem project https://github.com/mojombo/rakegem
# Seattle.rb - Hoe - cuz it has relly good stuff in there
#------------------------------------------------------------------------------
BEGIN {

require 'ostruct'
require 'rake/clean'
require 'rubygems' unless defined? Gem

module Util
def self.version
[ "lib/#{ This.name }.rb", "lib/#{ This.name }/version.rb" ].each do |v|
line = File.read( v )[/^\s*VERSION\s*=\s*.*/]
if line then
return line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
end
end
end

# Partition an rdoc file into sections and return the text of the section
# as an array of paragraphs
def self.section_of( file, section_name )
re = /^=+ (.*)$/
parts = File.read( file ).split( re )[1..-1]
parts.map! { |p| p.strip }

sections = Hash.new
Hash[*parts].each do |k,v|
sections[k] = v.split("\n\n")
end
return sections[section_name]
end

def self.task_warning( task )
warn "WARNING: '#{task}' tasks are not defined. Please run 'rake develop'"
end

def self.read_manifest
abort "You need a Manifest.txt" unless File.readable?( "Manifest.txt" )
File.readlines( "Manifest.txt" ).map { |l| l.strip }
end

def self.extension_conf_files
read_manifest.grep( /extconf.rb\Z/ )
end

def self.platform_gemspec
This.gemspec[This.platform]
end

def self.proj_root_path
Pathname.new( File.expand_path( "..", __FILE__ ) )
end

def self.proj_path(*args)
proj_root_path.join( *args )
end
end

# Hold all the metadata about this project
This = OpenStruct.new
This.platform = (RUBY_PLATFORM == "java") ? 'java' : Gem::Platform::RUBY

desc = Util.section_of( 'README.rdoc', 'DESCRIPTION')
This.summary = desc.first
This.description = desc.join(" ").tr("\n", ' ').gsub(/[{}]/,'').gsub(/\[[^\]]+\]/,'') # strip rdoc


This.exclude_from_manifest = %r/tmp$|\.(git|DS_Store)|^(doc|coverage|pkg)|Gemfile*|\.gemspec$|\.swp$|\.jar|\.rvmrc$|~$/
This.manifest = Util.read_manifest

}
load 'tasks/default.rake'

0 comments on commit af263f5

Please sign in to comment.