hpricot 0.8.2 → 0.8.3

data/CHANGELOG

@@ -1,16 +1,32 @@
+= 0.8.3
+=== 3 November, 2010
+* GH#8: Nil-check before downcasing attribute key
+* GH#25: Proper ruby 1.9 encoding support
+* GH#28. Use integers instead of ?? on 1.9, which is just a string.
+* including noscript to ElementInclusions , so that hpricot wont fail
+  when trying to parse a meta tag inside head section when noscript is
+  present.
+* latest changes from fast_xs mainline
+* Fixes to get Hpricot running on Rubinius:
+  * Use free, not XFREE
+  * Remove RSTRUCT craziness, don't break Array#at
+
 = 0.8.2
 === 5 November, 2009
 * Bring JRuby support up to speed, including Java-based hpricot_css support
 * Change JRuby fast_xs to have same escaping behavior as C fast_xs
-
-= 0.8.1
-=== 3 April, 2009
 * fix for issue #2, downcasing of html attributes inside the parser.
 * solve issue #3 with bogus etags being preserved in `to_s` rather than just `to_original_html`.
 * fix error when attempting to reparent cleared node. (issue #5)
 * Hpricot::Attributes proxy object for using `ele.attributes[k] = v` directly.
   however, it is preferred to use the jquery-like `elements.attr(k, v)`.
 
+= 0.8.1
+=== 3 April, 2009
+* big problems on Ruby 1.8.6, use INT2FIX instead of INT2NUM. hashes were being cast to bignums.
+* patch for 1.8.5 to define RARRAY_PTR. thanks, mike perham!
+* inspecting empty document bug, courtesy of @TalLevAmi.
+
 = 0.8
 === 31st March, 2009
 * Saving memory and speed by using RStruct-based elements in the C extension.

data/{README → README.md}

@@ -1,4 +1,4 @@
-= Hpricot, Read Any HTML
+# Hpricot, Read Any HTML
 
 Hpricot is a fast, flexible HTML parser written in C.  It's designed to be very
 accommodating (like Tanaka Akira's HTree) and to have a very helpful library
@@ -13,21 +13,21 @@ thing.
 *Please read this entire document* before making assumptions about how this
 software works.
 
-== An Overview
+## An Overview
 
 Let's clear up what Hpricot is.
 
-# Hpricot is *a standalone library*.  It requires no other libraries.  Just Ruby!
-# While priding itself on speed, Hpricot *works hard to sort out bad HTML* and
+* Hpricot is *a standalone library*.  It requires no other libraries.  Just Ruby!
+* While priding itself on speed, Hpricot *works hard to sort out bad HTML* and
   pays a small penalty in order to get that right.  So that's slightly more important
   to me than speed.
-# *If you can see it in Firefox, then Hpricot should parse it.*  That's
+* *If you can see it in Firefox, then Hpricot should parse it.*  That's
   how it should be!  Let me know the minute it's otherwise.
-# Primarily, Hpricot is used for reading HTML and tries to sort out troubled
+* Primarily, Hpricot is used for reading HTML and tries to sort out troubled
   HTML by having some idea of what good HTML is.  Some people still like to use
   Hpricot for XML reading, but *remember to use the Hpricot::XML() method* for that!
 
-== The Hpricot Kingdom
+## The Hpricot Kingdom
 
 First, here are all the links you need to know:
 
@@ -43,57 +43,57 @@ not going to say "Use at your own risk" because I don't want this library to be
 risky.  If you trip on something, I'll share the liability by repairing things
 as quickly as I can.  Your responsibility is to report the inadequacies.
 
-== Installing Hpricot
+## Installing Hpricot
 
 You may get the latest stable version from Rubyforge. Win32 binaries,
 Java binaries (for JRuby), and source gems are available.
 
-  $ gem install hpricot
+    $ gem install hpricot
 
-== An Hpricot Showcase
+## An Hpricot Showcase
 
 We're going to run through a big pile of examples to get you jump-started.
 Many of these examples are also found at
 http://wiki.github.com/hpricot/hpricot/hpricot-basics, in case you
 want to add some of your own.
 
-=== Loading Hpricot Itself
+### Loading Hpricot Itself
 
 You have probably got the gem, right?  To load Hpricot:
 
- require 'rubygems'
- require 'hpricot'
+    require 'rubygems'
+    require 'hpricot'
 
 If you've installed the plain source distribution, go ahead and just:
 
- require 'hpricot'
+    require 'hpricot'
 
-=== Load an HTML Page
+### Load an HTML Page
 
 The <tt>Hpricot()</tt> method takes a string or any IO object and loads the
 contents into a document object.
 
- doc = Hpricot("<p>A simple <b>test</b> string.</p>")
+    doc = Hpricot("<p>A simple <b>test</b> string.</p>")
 
 To load from a file, just get the stream open:
 
- doc = open("index.html") { |f| Hpricot(f) }
+    doc = open("index.html") { |f| Hpricot(f) }
 
 To load from a web URL, use <tt>open-uri</tt>, which comes with Ruby:
 
- require 'open-uri'
- doc = open("http://qwantz.com/") { |f| Hpricot(f) }
+    require 'open-uri'
+    doc = open("http://qwantz.com/") { |f| Hpricot(f) }
 
 Hpricot uses an internal buffer to parse the file, so the IO will stream
 properly and large documents won't be loaded into memory all at once.  However,
 the parsed document object will be present in memory, in its entirety.
 
-=== Search for Elements
+### Search for Elements
 
 Use <tt>Doc.search</tt>:
 
- doc.search("//p[@class='posted']")
- #=> #<Hpricot:Elements[{p ...}, {p ...}]>
+    doc.search("//p[@class='posted']")
+    #=> #<Hpricot:Elements[{p ...}, {p ...}]>
 
 <tt>Doc.search</tt> can take an XPath or CSS expression.  In the above example,
 all paragraph <tt><p></tt> elements are grabbed which have a <tt>class</tt>
@@ -101,126 +101,127 @@ attribute of <tt>"posted"</tt>.
 
 A shortcut is to use the divisor:
 
- (doc/"p.posted")
- #=> #<Hpricot:Elements[{p ...}, {p ...}]>
+    (doc/"p.posted")
+    #=> #<Hpricot:Elements[{p ...}, {p ...}]>
 
-=== Finding Just One Element
+### Finding Just One Element
 
 If you're looking for a single element, the <tt>at</tt> method will return the
 first element matched by the expression.  In this case, you'll get back the
 element itself rather than the <tt>Hpricot::Elements</tt> array.
 
- doc.at("body")['onload']
+    doc.at("body")['onload']
 
 The above code will find the body tag and give you back the <tt>onload</tt>
 attribute.  This is the most common reason to use the element directly: when
 reading and writing HTML attributes.
 
-=== Fetching the Contents of an Element
+### Fetching the Contents of an Element
 
 Just as with browser scripting, the <tt>inner_html</tt> property can be used to
 get the inner contents of an element.
 
- (doc/"#elementID").inner_html
- #=> "..<b>contents</b>.."
+    (doc/"#elementID").inner_html
+    #=> "..contents.."
 
 If your expression matches more than one element, you'll get back the contents
 of ''all the matched elements''.  So you may want to use <tt>first</tt> to be
 sure you get back only one.
 
- (doc/"#elementID").first.inner_html
- #=> "..<b>contents</b>.."
+    (doc/"#elementID").first.inner_html
+    #=> "..contents.."
 
-=== Fetching the HTML for an Element
+### Fetching the HTML for an Element
 
 If you want the HTML for the whole element (not just the contents), use
 <tt>to_html</tt>:
 
- (doc/"#elementID").to_html
- #=> "<div id='elementID'>...</div>"
+    (doc/"#elementID").to_html
+    #=> "<div id='elementID'>...</div>"
 
-=== Looping
+### Looping
 
 All searches return a set of <tt>Hpricot::Elements</tt>.  Go ahead and loop
 through them like you would an array.
 
- (doc/"p/a/img").each do |img|
-   puts img.attributes['class']
- end
+    (doc/"p/a/img").each do |img|
+      puts img.attributes['class']
+    end
 
-=== Continuing Searches
+### Continuing Searches
 
 Searches can be continued from a collection of elements, in order to search deeper.
 
- # find all paragraphs.
- elements = doc.search("/html/body//p")
- # continue the search by finding any images within those paragraphs.
- (elements/"img")
- #=> #<Hpricot::Elements[{img ...}, {img ...}]>
+    # find all paragraphs.
+    elements = doc.search("/html/body//p")
+    # continue the search by finding any images within those paragraphs.
+    (elements/"img")
+    #=> #<Hpricot::Elements[{img ...}, {img ...}]>
 
 Searches can also be continued by searching within container elements.
 
- # find all images within paragraphs.
- doc.search("/html/body//p").each do |para|
-   puts "== Found a paragraph =="
-   pp para
+    # find all images within paragraphs.
+    doc.search("/html/body//p").each do |para|
+      puts "== Found a paragraph =="
+      pp para
 
-   imgs = para.search("img")
-   if imgs.any?
-     puts "== Found #{imgs.length} images inside =="
-   end
- end
+      imgs = para.search("img")
+      if imgs.any?
+        puts "== Found #{imgs.length} images inside =="
+      end
+    end
 
 Of course, the most succinct ways to do the above are using CSS or XPath.
 
- # the xpath version
- (doc/"/html/body//p//img")
- # the css version
- (doc/"html > body > p img")
- # ..or symbols work, too!
- (doc/:html/:body/:p/:img)
+    # the xpath version
+    (doc/"/html/body//p//img")
+    # the css version
+    (doc/"html > body > p img")
+    # ..or symbols work, too!
+    (doc/:html/:body/:p/:img)
 
-=== Looping Edits
+### Looping Edits
 
 You may certainly edit objects from within your search loops.  Then, when you
 spit out the HTML, the altered elements will show.
 
- (doc/"span.entryPermalink").each do |span|
-   span.attributes['class'] = 'newLinks'
- end
- puts doc
+
+    (doc/"span.entryPermalink").each do |span|
+      span.attributes['class'] = 'newLinks'
+    end
+    puts doc
 
 This changes all <tt>span.entryPermalink</tt> elements to
 <tt>span.newLinks</tt>.  Keep in mind that there are often more convenient ways
 of doing this.  Such as the <tt>set</tt> method:
 
- (doc/"span.entryPermalink").set(:class => 'newLinks')
+    (doc/"span.entryPermalink").set(:class => 'newLinks')
 
-=== Figuring Out Paths
+### Figuring Out Paths
 
 Every element can tell you its unique path (either XPath or CSS) to get to the
 element from the root tag.
 
 The <tt>css_path</tt> method:
 
- doc.at("div > div:nth(1)").css_path
-   #=> "div > div:nth(1)" 
- doc.at("#header").css_path
-   #=> "#header" 
+    doc.at("div > div:nth(1)").css_path
+      #=> "div > div:nth(1)" 
+    doc.at("#header").css_path
+      #=> "#header" 
 
 Or, the <tt>xpath</tt> method:
 
- doc.at("div > div:nth(1)").xpath
-   #=> "/div/div:eq(1)" 
- doc.at("#header").xpath
-   #=> "//div[@id='header']" 
+    doc.at("div > div:nth(1)").xpath
+      #=> "/div/div:eq(1)" 
+    doc.at("#header").xpath
+      #=> "//div[@id='header']"
 
-== Hpricot Fixups
+## Hpricot Fixups
 
 When loading HTML documents, you have a few settings that can make Hpricot more
 or less intense about how it gets involved.
 
-== :fixup_tags
+## :fixup_tags
 
 Really, there are so many ways to clean up HTML and your intentions may be to
 keep the HTML as-is.  So Hpricot's default behavior is to keep things flexible.
@@ -229,7 +230,7 @@ Making sure to open and close all the tags, but ignore any validation problems.
 As of Hpricot 0.4, there's a new <tt>:fixup_tags</tt> option which will attempt
 to shift the document's tags to meet XHTML 1.0 Strict.
 
- doc = open("index.html") { |f| Hpricot f, :fixup_tags => true }
+    doc = open("index.html") { |f| Hpricot f, :fixup_tags => true }
 
 This doesn't quite meet the XHTML 1.0 Strict standard, it just tries to follow
 the rules a bit better.  Like: say Hpricot finds a paragraph in a link, it's
@@ -238,13 +239,13 @@ where paragraphs don't belong.
 
 If an unknown element is found, it is ignored.  Again, <tt>:fixup_tags</tt>.
 
-== :xhtml_strict
+## :xhtml_strict
 
 So, let's go beyond just trying to fix the hierarchy.  The
 <tt>:xhtml_strict</tt> option really tries to force the document to be an XHTML
 1.0 Strict document.  Even at the cost of removing elements that get in the way.
 
- doc = open("index.html") { |f| Hpricot f, :xhtml_strict => true }
+    doc = open("index.html") { |f| Hpricot f, :xhtml_strict => true }
 
 What measures does <tt>:xhtml_strict</tt> take?
 
@@ -254,7 +255,7 @@ What measures does <tt>:xhtml_strict</tt> take?
  4. Remove illegal content.
  5. Alter the doctype to XHTML 1.0 Strict.
 
-== Hpricot.XML()
+## Hpricot.XML()
 
 The last option is the <tt>:xml</tt> option, which makes some slight variations
 on the standard mode.  The main difference is that :xml mode won't try to output
@@ -266,9 +267,9 @@ to case, friends.
 
 The primary way to use Hpricot's XML mode is to call the Hpricot.XML method:
 
- doc = open("http://redhanded.hobix.com/index.xml") do |f|
-   Hpricot.XML(f)
- end
+    doc = open("http://redhanded.hobix.com/index.xml") do |f|
+      Hpricot.XML(f)
+    end
 
 *Also, :fixup_tags is canceled out by the :xml option.*  This is because
 :fixup_tags makes assumptions based how HTML is structured.  Specifically, how

data/Rakefile

@@ -1,10 +1,12 @@
-require 'rake'
 require 'rake/clean'
 require 'rake/gempackagetask'
 require 'rake/rdoctask'
 require 'rake/testtask'
-require 'fileutils'
-include FileUtils
+begin
+  require 'rake/extensiontask'
+rescue LoadError
+  abort "To build, please first gem install rake-compiler"
+end
 
 RbConfig = Config unless defined?(RbConfig)
 
@@ -12,13 +14,14 @@ NAME = "hpricot"
 REV = (`#{ENV['GIT'] || "git"} rev-list HEAD`.split.length + 1).to_s
 VERS = ENV['VERSION'] || "0.8" + (REV ? ".#{REV}" : "")
 PKG = "#{NAME}-#{VERS}"
-BIN = "*.{bundle,jar,so,o,obj,pdb,lib,def,exp,class}"
-CLEAN.include ["ext/hpricot_scan/#{BIN}", "ext/fast_xs/#{BIN}", "lib/**/#{BIN}",
+BIN = "*.{bundle,jar,so,o,obj,pdb,lib,def,exp,class,rbc}"
+CLEAN.include ["#{BIN}", "ext/**/#{BIN}", "lib/**/#{BIN}", "test/**/#{BIN}",
                'ext/fast_xs/Makefile', 'ext/hpricot_scan/Makefile',
-               '**/.*.sw?', '*.gem', '.config', 'pkg']
-RDOC_OPTS = ['--quiet', '--title', 'The Hpricot Reference', '--main', 'README', '--inline-source']
-PKG_FILES = %w(CHANGELOG COPYING README Rakefile) +
-      Dir.glob("{bin,doc,test,lib,extras}/**/*") +
+               '**/.*.sw?', '*.gem', '.config', 'pkg', 'lib/hpricot_scan.rb', 'lib/fast_xs.rb']
+RDOC_OPTS = ['--quiet', '--title', 'The Hpricot Reference', '--main', 'README.md', '--inline-source']
+PKG_FILES = %w(CHANGELOG COPYING README.md Rakefile) +
+      Dir.glob("{bin,doc,test,extras}/**/*") +
+      (Dir.glob("lib/**/*.rb") - %w(lib/hpricot_scan.rb lib/fast_xs.rb)) +
       Dir.glob("ext/**/*.{h,java,c,rb,rl}") +
       %w[ext/hpricot_scan/hpricot_scan.c ext/hpricot_scan/hpricot_css.c ext/hpricot_scan/HpricotScanService.java] # needed because they are generated later
 RAGEL_C_CODE_GENERATION_STYLES = {
@@ -39,7 +42,7 @@ SPEC =
     s.platform = Gem::Platform::RUBY
     s.has_rdoc = true
     s.rdoc_options += RDOC_OPTS
-    s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
+    s.extra_rdoc_files = ["README.md", "CHANGELOG", "COPYING"]
     s.summary = "a swift, liberal HTML parser with a fantastic library"
     s.description = s.summary
     s.author = "why the lucky stiff"
@@ -52,26 +55,54 @@ SPEC =
     s.bindir = "bin"
   end
 
-Win32Spec = SPEC.dup
-Win32Spec.platform = 'x86-mswin32'
-Win32Spec.files = PKG_FILES + ["lib/hpricot_scan.so", "lib/fast_xs.so"]
-Win32Spec.extensions = []
+# FAT cross-compile
+# Pass RUBY_CC_VERSION=1.8.7:1.9.2 when packaging for 1.8+1.9 mswin32 binaries
+%w(hpricot_scan fast_xs).each do |target|
+  Rake::ExtensionTask.new(target, SPEC) do |ext|
+    ext.lib_dir = File.join('lib', target) if ENV['RUBY_CC_VERSION']
+    ext.cross_compile = true                # enable cross compilation (requires cross compile toolchain)
+    ext.cross_platform = 'i386-mswin32'     # forces the Windows platform instead of the default one
+  end
 
-WIN32_PKG_DIR = "#{PKG}-mswin32"
+  # HACK around 1.9.2 cross .def file creation
+  def_file = "tmp/i386-mswin32/#{target}/1.9.2/#{target}-i386-mingw32.def"
+  directory File.dirname(def_file)
+  file def_file => File.dirname(def_file) do |t|
+    File.open(t.name, "w") do |f|
+      f << "EXPORTS\nInit_#{target}\n"
+    end
+  end
+
+  task File.join(File.dirname(def_file), "Makefile") => def_file
+  # END HACK
+  file "lib/#{target}.rb" do |t|
+    File.open(t.name, "w") do |f|
+      f.puts %{require "#{target}/\#{RUBY_VERSION.sub(/\\.\\d+$/, '')}/#{target}"}
+    end
+  end
+end
+file 'ext/hpricot_scan/extconf.rb' => :ragel
+
+desc "set environment variables to build and/or test with debug options"
+task :debug do
+  ENV['CFLAGS'] ||= ""
+  ENV['CFLAGS'] += " -g -DDEBUG"
+end
 
 desc "Does a full compile, test run"
 if defined?(JRUBY_VERSION)
-task :default => [:compile_java, :test]
+task :default => [:compile_java, :clean_fat_rb, :test]
 else
-task :default => [:compile, :test]
+task :default => [:compile, :clean_fat_rb, :test]
 end
 
-desc "Packages up Hpricot."
-task :package => [:clean, :ragel]
-
-desc "Releases packages for all Hpricot packages and platforms."
-task :release => [:package, :package_win32, :package_jruby]
+task :clean_fat_rb do
+  rm_f "lib/hpricot_scan.rb"
+  rm_f "lib/fast_xs.rb"
+end
 
+desc "Packages up Hpricot for all platforms."
+task :package => [:clean]
 
 desc "Run all the tests"
 Rake::TestTask.new do |t|
@@ -83,8 +114,8 @@ end
 Rake::RDocTask.new do |rdoc|
     rdoc.rdoc_dir = 'doc/rdoc'
     rdoc.options += RDOC_OPTS
-    rdoc.main = "README"
-    rdoc.rdoc_files.add ['README', 'CHANGELOG', 'COPYING', 'lib/**/*.rb']
+    rdoc.main = "README.md"
+    rdoc.rdoc_files.add ['README.md', 'CHANGELOG', 'COPYING', 'lib/**/*.rb']
 end
 
 Rake::GemPackageTask.new(SPEC) do |p|
@@ -92,53 +123,32 @@ Rake::GemPackageTask.new(SPEC) do |p|
     p.gem_spec = SPEC
 end
 
-['hpricot_scan', 'fast_xs'].each do |extension|
-  ext = "ext/#{extension}"
-  ext_so = "#{ext}/#{extension}.#{Config::CONFIG['DLEXT']}"
-  ext_files = FileList[
-    "#{ext}/*.c",
-    "#{ext}/*.h",
-    "#{ext}/*.rl",
-    "#{ext}/extconf.rb",
-    "#{ext}/Makefile",
-    "lib"
-  ]
-
-  desc "Builds just the #{extension} extension"
-  task extension.to_sym => [:ragel, "#{ext}/Makefile", ext_so ]
-
-  file "#{ext}/Makefile" => ["#{ext}/extconf.rb"] do
-    Dir.chdir(ext) do ruby "extconf.rb" end
-  end
-
-  file ext_so => ext_files do
-    Dir.chdir(ext) do
-      sh(RUBY_PLATFORM =~ /mswin/ ? 'nmake' : 'make')
+### Win32 Packages ###
+Win32Spec = SPEC.dup
+Win32Spec.platform = 'i386-mswin32'
+Win32Spec.files = PKG_FILES + %w(hpricot_scan fast_xs).map do |t|
+  unless ENV['RUBY_CC_VERSION']
+    file "lib/#{t}/1.8/#{t}.so" do
+      abort "ERROR while packaging: re-run for fat win32 gems:\nrake #{ARGV.join(' ')} RUBY_CC_VERSION=1.8.7:1.9.2"
     end
-    cp ext_so, "lib"
   end
+  ["lib/#{t}.rb", "lib/#{t}/1.8/#{t}.so", "lib/#{t}/1.9/#{t}.so"]
+end.flatten
+Win32Spec.extensions = []
 
-  desc "Cross-compile the #{extension} extension for win32"
-  file "#{extension}_win32" => [WIN32_PKG_DIR] do
-    cp "extras/mingw-rbconfig.rb", "#{WIN32_PKG_DIR}/ext/#{extension}/rbconfig.rb"
-    sh "cd #{WIN32_PKG_DIR}/ext/#{extension}/ && ruby -I. extconf.rb && make"
-    mv "#{WIN32_PKG_DIR}/ext/#{extension}/#{extension}.so", "#{WIN32_PKG_DIR}/lib"
-  end
+Rake::GemPackageTask.new(Win32Spec) do |p|
+  p.need_tar = false
+  p.gem_spec = Win32Spec
 end
 
-task "lib" do
-  directory "lib"
-end
+JRubySpec = SPEC.dup
+JRubySpec.platform = 'java'
+JRubySpec.files = PKG_FILES + ["lib/hpricot_scan.jar", "lib/fast_xs.jar"]
+JRubySpec.extensions = []
 
-desc "Compiles the Ruby extension"
-task :compile => [:hpricot_scan, :fast_xs] do
-  if Dir.glob(File.join("lib","hpricot_scan.*")).length == 0
-    STDERR.puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
-    STDERR.puts "Gem actually failed to build.  Your system is"
-    STDERR.puts "NOT configured properly to build hpricot."
-    STDERR.puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
-    exit(1)
-  end
+Rake::GemPackageTask.new(JRubySpec) do |p|
+  p.need_tar = false
+  p.gem_spec = JRubySpec
 end
 
 desc "Determines the Ragel version and displays it on the console along with the location of the Ragel binary."
@@ -178,27 +188,7 @@ task :ragel_java => [:ragel_version] do
   end
 end
 
-### Win32 Packages ###
-
-desc "Package up the Win32 distribution."
-file WIN32_PKG_DIR => [:package] do
-  sh "tar zxf pkg/#{PKG}.tgz"
-  mv PKG, WIN32_PKG_DIR
-end
-
-desc "Build the binary RubyGems package for win32"
-task :package_win32 => ["fast_xs_win32", "hpricot_scan_win32"] do
-  Dir.chdir("#{WIN32_PKG_DIR}") do
-    Gem::Builder.new(Win32Spec).build
-    verbose(true) {
-      mv Dir["*.gem"].first, "../pkg/"
-    }
-  end
-end
-
-CLEAN.include WIN32_PKG_DIR
-
-### JRuby Packages ###
+### JRuby Compile ###
 
 def java_classpath_arg # myriad of ways to discover JRuby classpath
   begin
@@ -211,7 +201,11 @@ def java_classpath_arg # myriad of ways to discover JRuby classpath
     jruby_cpath = ENV['JRUBY_PARENT_CLASSPATH'] || ENV['JRUBY_HOME'] &&
       FileList["#{ENV['JRUBY_HOME']}/lib/*.jar"].join(File::PATH_SEPARATOR)
   end
-  jruby_cpath ? "-cp \"#{jruby_cpath}\"" : ""
+  unless jruby_cpath || ENV['CLASSPATH'] =~ /jruby/
+    abort %{WARNING: No JRuby classpath has been set up.
+Define JRUBY_HOME=/path/to/jruby on the command line or in the environment}
+  end
+  "-cp \"#{jruby_cpath}\""
 end
 
 def compile_java(filenames, jarname)
@@ -231,42 +225,10 @@ task :fast_xs_java do
   end
 end
 
-desc "Compiles the JRuby extensions"
-task :compile_java => [:hpricot_scan_java, :fast_xs_java] do
-  %w(hpricot_scan fast_xs).each {|ext| mv "ext/#{ext}/#{ext}.jar", "lib"}
-end
-
-JRubySpec = SPEC.dup
-JRubySpec.platform = 'java'
-JRubySpec.files = PKG_FILES + ["lib/hpricot_scan.jar", "lib/fast_xs.jar"]
-JRubySpec.extensions = []
-
-JRUBY_PKG_DIR = "#{PKG}-java"
-
-desc "Package up the JRuby distribution."
-file JRUBY_PKG_DIR => [:ragel_java, :package] do
-  sh "tar zxf pkg/#{PKG}.tgz"
-  mv PKG, JRUBY_PKG_DIR
-end
-
-desc "Build the RubyGems package for JRuby"
-task :package_jruby => JRUBY_PKG_DIR do
-  Dir.chdir("#{JRUBY_PKG_DIR}") do
-    Rake::Task[:compile_java].invoke
-    Gem::Builder.new(JRubySpec).build
-    verbose(true) {
-      mv Dir["*.gem"].first, "../pkg/#{JRUBY_PKG_DIR}.gem"
-    }
+%w(hpricot_scan fast_xs).each do |ext|
+  file "lib/#{ext}.jar" => "#{ext}_java" do |t|
+    mv "ext/#{ext}/#{ext}.jar", "lib"
   end
+  task :compile_java => "lib/#{ext}.jar"
 end
 
-CLEAN.include JRUBY_PKG_DIR
-
-task :install do
-  sh %{rake package}
-  sh %{sudo gem install pkg/#{NAME}-#{VERS}}
-end
-
-task :uninstall => [:clean] do
-  sh %{sudo gem uninstall #{NAME}}
-end