heel 2.0.0 → 3.0.0

data/spec/rackapp_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 require 'rack/mock'
 require 'heel/rackapp'
 
@@ -10,34 +10,34 @@ describe Heel::RackApp do
 
   it "should return the a listing for the currrent directory" do
     res = @request.get("/")
-    res.should be_ok
-    res['Content-Type'].should == "text/html"
-    res.body.should =~ /Rakefile/
+    res.must_be :ok?
+    res['Content-Type'].must_equal "text/html"
+    res.body.must_match( /Rakefile/ )
   end
 
   it 'should highlight a ruby file' do
-    res = @request.get("/gemspec.rb")
-    res.should be_ok
-    res['Content-Type'].should == "text/html"
-    res.body.should =~ /class="CodeRay"/
+    res = @request.get("/lib/heel.rb")
+    res.must_be :ok?
+    res['Content-Type'].must_equal "text/html"
+    res.body.must_match( /class="CodeRay"/ )
   end
 
   it "should not highlight a ruby file if told not to" do
-    res = @request.get("/gemspec.rb?highlighting=off")
-    res.should be_ok
-    res.body.size.should == File.size("gemspec.rb")
-    res['Content-Type'].should == "application/x-ruby"
+    res = @request.get("/lib/heel.rb?highlighting=off")
+    res.must_be :ok?
+    res.body.size.must_equal File.size("lib/heel.rb")
+    res['Content-Type'].must_equal "application/x-ruby"
   end
 
   it "should return a 405 if given a non-GET request" do
     res = @request.post("/")
-    res.should_not be_ok
-    res.status.should == 405
+    res.wont_be :ok?
+    res.status.must_equal 405
   end
 
   it "should return a 403 if accessing an invalid location" do
     res = @request.get("/../../../../etc/passwd")
-    res.should_not be_ok
-    res.status.should == 403
+    res.wont_be :ok?
+    res.status.must_equal 403
   end
 end

data/spec/server_spec.rb

@@ -1,4 +1,5 @@
-require "spec/spec_helper"
+require "spec_helper"
+
 describe Heel::Server do
   before(:each) do 
     @stdin = StringIO.new
@@ -18,8 +19,8 @@ describe Heel::Server do
     begin
       server.run
     rescue SystemExit => se
-      se.status.should == 0
-      @stdout.string.should =~ /version #{Heel::VERSION}/
+      se.status.must_equal 0
+      @stdout.string.must_match( /version #{Heel::VERSION}/ )
     end
   end
 
@@ -29,8 +30,8 @@ describe Heel::Server do
     begin
       server.run
     rescue SystemExit => se
-      se.status.should == 0
-      @stdout.string.should =~ /Usage/m
+      se.status.must_equal 0
+      @stdout.string.must_match( /Usage/m )
     end
   end
 
@@ -40,8 +41,8 @@ describe Heel::Server do
     begin
       server.run
     rescue SystemExit => se
-      se.status.should == 1
-      @stdout.string.should =~ /Try .*--help/m
+      se.status.must_equal 1
+      @stdout.string.must_match( /Try .*--help/m )
     end
   end
 
@@ -51,34 +52,34 @@ describe Heel::Server do
     begin
       server.run
     rescue SystemExit => se
-      se.status.should == 1
-      @stdout.string.should =~ /Try .*--help/m
+      se.status.must_equal 1
+      @stdout.string.must_match( /Try .*--help/m )
     end
   end
 
   it "should allow port and address to be set" do
     server = Heel::Server.new(%w[--port 4242 --address 192.168.1.1])
     server.merge_options
-    server.options.address.should == "192.168.1.1"
-    server.options.port.should == 4242        
+    server.options.address.must_equal "192.168.1.1"
+    server.options.port.must_equal 4242
   end
 
   it "should allow the highlighting option to be set" do
     server = Heel::Server.new(%w[--highlighting])
     server.merge_options
-    server.options.highlighting.should == true
+    server.options.highlighting.must_equal true
   end
 
   it "should have highlighting off as a default" do
     server = Heel::Server.new
     server.merge_options
-    server.options.highlighting.should == false
+    server.options.highlighting.must_equal false
   end
 
-  it "should set no-launch-browser option and kill option" do
+  it "should set no-launch-browser option" do
     server = Heel::Server.new(%w[--no-launch-browser])
     server.merge_options
-    server.options.launch_browser.should == false
+    server.options.launch_browser.must_equal false
   end
 
   it "should attempt to kill the process" do
@@ -89,18 +90,18 @@ describe Heel::Server do
       server.run
       violated("Should have thrown SystemExit")
     rescue SystemExit => se
-      se.status.should == 0
-      @stdout.string.should =~ /Done/m
+      se.status.must_equal 0
+      @stdout.string.must_match( /Done/m )
     end
   end
 
   it "should setup a heel directory" do
     server = Heel::Server.new(%w[--daemonize])
     server.set_io(@stdin,@stdout)
-    File.directory?(server.default_directory).should == false
+    File.directory?(server.default_directory).must_equal false
     server.setup_heel_dir
-    File.directory?(server.default_directory).should == true
-    @stdout.string.should =~ /Created/m
+    File.directory?(server.default_directory).must_equal true
+    @stdout.string.must_match( /Created/m )
   end
 
   it "should send a signal to a pid" do
@@ -113,8 +114,8 @@ describe Heel::Server do
       server.run
       violated("Should have exited")
     rescue SystemExit => se
-      se.status.should == 0
-      @stdout.string.should =~ /Sending TERM to process -42/m
+      se.status.must_equal 0
+      @stdout.string.must_match( /Sending TERM to process -42/m )
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,10 @@
-begin
-    require 'rubygems'
-    require 'heel'
-    require 'spec'
-    require 'net/http'
-rescue LoadError
-    $: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
-    require 'heel'
-end
+if RUBY_VERSION >= '1.9.2' then
+  require 'simplecov'
+  puts "Using coverage!"
+  SimpleCov.start if ENV['COVERAGE']
+end
+
+gem 'minitest'
+require 'heel'
+require 'minitest/autorun'
+require 'minitest/pride'

data/tasks/default.rake

@@ -0,0 +1,212 @@
+# vim: syntax=ruby
+require 'rake/clean'
+#------------------------------------------------------------------------------
+# 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
+
+    This.set_coverage_gem
+
+    puts "Installing gem depedencies needed for development"
+    This.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"
+
+#------------------------------------------------------------------------------
+# Minitest - standard TestTask
+#------------------------------------------------------------------------------
+begin
+  require 'rake/testtask'
+  Rake::TestTask.new( :test ) do |t|
+    t.ruby_opts    = %w[ -w -rubygems ]
+    t.libs         = %w[ lib spec ]
+    t.pattern      = "spec/**/*_spec.rb"
+  end
+  task :default => :test
+rescue LoadError
+  This.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
+  This.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.0"
+  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
+   This.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
+    This.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
+#------------------------------------------------------------------------------
+desc "Look for fixmes and report them"
+task :fixme => 'manifest:check' do
+  This.manifest.each do |file|
+    next if file == __FILE__
+    next unless file =~ %r/(txt|rb|md|rdoc|css|html|xml|css)\Z/
+    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
+#------------------------------------------------------------------------------
+# 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 This.platform_gemspec.to_ruby
+  end
+end
+
+# the gemspec is also a dev artifact and should not be kept around.
+CLOBBER << This.gemspec_file
+
+# The standard gem packaging task, everyone has it.
+require 'rubygems/package_task'
+Gem::PackageTask.new( This.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 #{This.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/#{This.platform_gemspec.full_name}.gem"
+end

data/tasks/this.rb

@@ -0,0 +1,202 @@
+require 'pathname'
+
+# Public: A Class containing all the metadata and utilities needed to manage a
+# ruby project.
+class ThisProject
+  # The name of this project
+  attr_accessor :name
+
+  # The author's name
+  attr_accessor :author
+
+  # The email address of the author(s)
+  attr_accessor :email
+
+  # The homepage of this project
+  attr_accessor :homepage 
+
+  # The regex of files to exclude from the manifest
+  attr_accessor :exclude_from_manifest
+
+  # The hash of Gem::Specifications keyed' by platform
+  attr_accessor :gemspecs
+
+  # Public: Initialize ThisProject
+  #
+  # Yields self
+  def initialize(&block)
+    @exclude_from_manifest = %r/tmp$|\.(git|DS_Store)|^(doc|coverage|pkg)|Gemfile*|\.gemspec$|\.swp$|\.jar|\.rvmrc$|~$/
+    @gemspecs              = Hash.new
+    yield self if block_given?
+  end
+
+  # Public: return the version of ThisProject
+  #
+  # Search the ruby files in the project looking for the one that has the
+  # version string in it. This does not eval any code in the project, it parses
+  # the source code looking for the string.
+  #
+  # Returns a String version
+  def version
+    [ "lib/#{ name }.rb", "lib/#{ name }/version.rb" ].each do |v|
+      path = project_path( v )
+      line = path.read[/^\s*VERSION\s*=\s*.*/]
+      if line then
+        return line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+      end
+    end
+  end
+
+  # Internal: Return a section of an RDoc file with the given section name
+  #
+  # path         - the relative path in the project of the file to parse
+  # section_name - the section out of the file from which to parse data
+  #
+  # Retuns the text of the section as an array of paragrphs.
+  def section_of( file, section_name )
+    re    = /^=+ (.*)$/
+    sectional = project_path( file )
+    parts = sectional.read.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
+
+  # Internal: print out a warning about the give task
+  def task_warning( task )
+    warn "WARNING: '#{task}' tasks are not defined. Please run 'rake develop'"
+  end
+
+  # Internal: Return the full path to the file that is relative to the project
+  # root.
+  #
+  # path - the relative path of the file from the project root
+  #
+  # Returns the Pathname of the file
+  def project_path( relative_path )
+    project_root.join( relative_path )
+  end
+
+  # Internal: The absolute path of this file
+  #
+  # Returns the Pathname of this file.
+  def this_file_path
+    Pathname.new( __FILE__ ).expand_path
+  end
+
+  # Internal: The root directory of this project
+  #
+  # This is defined as being the directory that is in the path of this project
+  # that has the first Rakefile
+  #
+  # Returns the Pathname of the directory
+  def project_root
+    this_file_path.ascend do |p|
+      rakefile = p.join( 'Rakefile' )
+      return p if rakefile.exist?
+    end
+  end
+
+  # Internal: Returns the contents of the Manifest.txt file as an array
+  #
+  # Returns an Array of strings
+  def manifest
+    manifest_file = project_path( "Manifest.txt" )
+    abort "You need a Manifest.txt" unless manifest_file.readable?
+    manifest_file.readlines.map { |l| l.strip }
+  end
+
+  # Internal: Returns the gemspace associated with the current ruby platform
+  def platform_gemspec
+    gemspecs.fetch( platform, ruby_gemspec )
+  end
+
+  def core_gemspec
+    Gem::Specification.new do |spec|
+      spec.name        = name
+      spec.version     = version
+      spec.author      = author
+      spec.email       = email
+      spec.homepage    = homepage
+
+      spec.summary     = summary
+      spec.description = description
+
+      spec.files       = 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',
+                            "--markup", "tomdoc" ]
+    end
+  end
+
+  # Internal: Return the gemspec for the ruby platform
+  def ruby_gemspec( core = core_gemspec, &block )
+    yielding_gemspec( 'ruby', core, &block )
+  end
+
+  # Internal: Return the gemspec for the jruby platform
+  def java_gemspec( core = core_gemspec, &block )
+    yielding_gemspec( 'java', core, &block )
+  end
+
+  # Internal: give an initial spec and a key, create a new gemspec based off of
+  # it.
+  #
+  # This will force the new gemspecs 'platform' to be that of the key, since the
+  # only reason you would have multiple gemspecs at this point is to deal with
+  # different platforms.
+  def yielding_gemspec( key, core )
+    spec = gemspecs[key] ||= core.dup
+    spec.platform = key
+    yield spec if block_given?
+    return spec
+  end
+
+  # Internal: Set the recovery gem development dependency
+  #
+  # These are dynamically set since they cannot be hard coded as there is 
+  # no way to ship them correctly in the gemspec
+  #
+  # Returns nothing.
+  def set_coverage_gem
+    if RUBY_VERSION < "1.9.0"
+      platform_gemspec.add_development_dependency( 'rcov', '~> 1.0.0' )
+    else
+      platform_gemspec.add_development_dependency( 'simplecov', '~> 0.7.1' )
+    end
+  end
+
+  # Internal: Return the platform of ThisProject at the current moment in time.
+  def platform
+    (RUBY_PLATFORM == "java") ? 'java' : Gem::Platform::RUBY
+  end
+
+  # Internal: Return the DESCRIPTION section of the README.rdoc file
+  def description_section
+    section_of( 'README.rdoc', 'DESCRIPTION')
+  end
+ 
+ # Internal: Return the summary text from the README 
+  def summary
+    description_section.first
+  end
+
+  # Internal: Return the full description text from the READEM
+  def description
+    description_section.join(" ").tr("\n", ' ').gsub(/[{}]/,'').gsub(/\[[^\]]+\]/,'') # strip rdoc
+  end
+
+  # Internal: The path to the gemspec file
+  def gemspec_file
+    project_path( "#{ name }.gemspec" )
+  end
+end
+
+This = ThisProject.new