magellan 0.1.0

data/README

@@ -0,0 +1,11 @@
+Magellan: (alpha)
+
+Currently the supported functionality is a rake task that crawl your website and find any broken a[@href], img[@src], or script[@src] links.
+
+Magellan::Rake::Task.new do |t|
+  t.origin_url = "http://localhost:3000/"
+  t.explore_depth = 100
+end
+
+Assumptions:
+This tool works best if you follow the rules of unobtrusive javascript and property set the http status code header.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 0
+:major: 0

data/lib/magellan.rb

@@ -0,0 +1,13 @@
+require 'magellan/cartographer'
+require 'magellan/explorer'
+require 'magellan/result'
+require 'magellan/broken_link_tracker'
+require 'magellan/expected_links_tracker'
+require 'magellan/logger'
+require 'magellan/extensions/string'
+require 'magellan/extensions/array'
+require 'magellan/extensions/mechanize_page'
+
+module Magellan
+  VERSION = '0.0.1'
+end

data/lib/magellan/broken_link_tracker.rb

@@ -0,0 +1,30 @@
+module Magellan
+  class BrokenLinkTracker
+    include Observable
+    
+    attr_reader :broken_links
+
+    def initialize
+      @broken_links = []
+      @first_linked_from = {}
+    end
+
+    def update(time,result)
+      failed = result.status_code.starts_with?("5") || result.status_code.starts_with?("4")
+      @broken_links << result if failed
+      changed
+      notify_observers(Time.now, !failed)
+      result.absolute_linked_resources.each do |linked_resource|
+        @first_linked_from[linked_resource] = result.url if !@first_linked_from.has_key?(linked_resource)
+      end
+    end
+
+    def failed?
+      !@broken_links.empty?
+    end
+
+    def failure_message
+      @broken_links.map{|broken_link| "#{broken_link.url} first linked from: #{@first_linked_from[broken_link.url]} returned: #{broken_link.status_code}"}.join("\n")
+    end
+  end
+end

data/lib/magellan/cartographer.rb

@@ -0,0 +1,70 @@
+require 'activesupport'
+require 'observer'
+
+module Magellan
+  class Cartographer
+    include Observable
+
+    def initialize(settings)
+      @origin_url = settings[:origin_url]
+      @known_urls = settings[:ignored_urls]
+      @domains = settings[:domains].map {|domain| URI.parse(domain)}
+      @depth_to_explore = settings[:depth_to_explore]
+      @links_we_want_to_explore = settings[:links_to_explore]
+      @trace = settings[:trace]
+    end
+
+    def crawl
+      recursive_explore([@origin_url],1)
+    end
+
+    def recursive_explore(urls,depth)
+      if i_am_not_too_deep?(depth)
+        $stdout.puts "exploring:\n#{urls.join("\n")}" if @trace
+        results = Explorer.new(urls,@links_we_want_to_explore).explore
+        results.each do |result|
+          changed
+          notify_observers(Time.now, result)
+          @known_urls << result.url.remove_fragment
+          @known_urls << result.destination_url.remove_fragment
+          remove_javascript_and_print_warning result
+        end
+
+        all_urls = results.map {|result| result.absolute_linked_resources }.flatten
+        all_urls.uniq!
+        #TODO: handle any other url parsing error
+        all_urls.delete_if { |url| !a_domain_we_care_about?(url)}
+        all_urls.delete_if { |url| i_have_seen_this_url_before?(url)}
+        all_urls.chunk(40).each do |result_chunk|
+          recursive_explore(result_chunk,depth+1)
+        end
+      end
+    end
+
+    def i_have_seen_this_url_before?(url)
+      @known_urls.include?(url.remove_fragment)
+    end
+
+    def i_am_not_too_deep?(depth)
+      depth <= @depth_to_explore
+    end
+
+    def a_domain_we_care_about?(url)
+      begin
+        !@domains.select { |domain| URI.parse(url).host == domain.host }.empty?
+      rescue
+        !@domains.select { |domain| url.gsub(/https*:\/\//,'').starts_with?(domain.host) }.empty?
+      end
+    end
+
+    def remove_javascript_and_print_warning(result)
+      result.linked_resources.delete_if do |linked_resource|
+        starts_with_javascript = linked_resource.downcase.starts_with?("javascript:")
+        #TODO: put this in the logger
+        #$stderr.puts "Found obtrusive javascript: #{linked_resource} on page #{result.url}" if starts_with_javascript
+        starts_with_javascript
+      end
+    end
+
+  end
+end

data/lib/magellan/expected_links_tracker.rb

@@ -0,0 +1,55 @@
+module Magellan
+  class ExpectedLinksTracker
+    include Observable
+    attr_reader :errors
+
+    def initialize(expected_patterns)
+      @errors = []
+      @expected_patterns = expected_patterns
+      @evaluated_expectations = {}
+    end
+
+    def update(time,result)
+      if result.html_content?
+        patterns_that_apply(result).each do |pattern,expectation|
+          passed = result.linked_resources.include?(expectation)
+          changed
+          notify_observers(Time.now, passed)
+          @errors << "#{result.url} did not contain a link to #{expectation}" unless passed
+        end
+      end
+    end
+
+    def patterns_that_apply(result)
+      res = @expected_patterns.select{|pattern,expecation| result.url =~ pattern || result.destination_url =~ pattern}
+      res.each { |expected_pattern| @evaluated_expectations[expected_pattern] = nil }
+      res
+    end
+
+    def has_errors?
+      !@errors.empty?
+    end
+
+    def unmet_expecations?
+      !unmet_expecations.empty?
+    end
+
+    def failed?
+      unmet_expecations? || has_errors?
+    end
+
+    def failure_message
+      unmet_expecations_messages << errors.join("\n")
+    end
+
+    def unmet_expecations_messages
+      message = "\n\n"
+      unmet_expecations.each {|pattern,unmet_expecation| message << "#{pattern} was never evaluted during the crawl\n"}
+      message
+    end
+
+    def unmet_expecations
+      @expected_patterns - @evaluated_expectations.keys
+    end
+  end
+end

data/lib/magellan/explorer.rb

@@ -0,0 +1,45 @@
+require 'hpricot'
+require 'open-uri'
+require 'ostruct'
+
+module Magellan
+  class Explorer
+    UNKNOWN_CONTENT = "unknown"
+    def initialize(urls,links)
+      @links = links
+      @urls = urls
+    end
+
+    def explore
+      reqs = []
+      @urls.each do |url|
+        reqs.push Thread.new { explore_a(url) }
+      end
+      reqs.collect { |req| req.value }
+    end
+
+    def explore_a(url)
+      begin
+        agent = WWW::Mechanize.new
+        agent.user_agent = "Ruby/#{RUBY_VERSION}"
+        doc = agent.get(url)
+        destination_url = doc.uri.to_s
+        status_code = doc.code
+        #TODO: clean this up, this is very hacky, I would rather pass in a hpricot doc to create a result
+        if doc.respond_to?(:content_type) && doc.content_type.starts_with?("text/html")
+          Explorer.create_result(url, destination_url, status_code, doc.links_to_other_documents(@links),doc.content_type)
+        else
+          Explorer.create_result(url, destination_url, status_code, [], doc.respond_to?(:content_type) ? doc.content_type : UNKNOWN_CONTENT)
+        end
+      rescue WWW::Mechanize::ResponseCodeError => the_error
+        Explorer.create_result(url, url, the_error.response_code, [],UNKNOWN_CONTENT)
+      rescue Timeout::Error
+        Explorer.create_result(url, url, "505", [],UNKNOWN_CONTENT)
+      end
+    end
+
+    def self.create_result(url,destination_url,status_code,links,content_type)
+      Result.new(status_code,url,destination_url,links.map{|link| link.to_s},content_type)
+    end
+  end
+end

data/lib/magellan/extensions/array.rb

@@ -0,0 +1,10 @@
+class Array
+  def chunk(max_size)
+    result = []
+    number_of_chunks = (self.size.to_f / max_size).ceil
+    for i in 0...number_of_chunks do
+      result << self[i*max_size...(i+1)*max_size]
+    end
+    result
+  end
+end

data/lib/magellan/extensions/mechanize_page.rb

@@ -0,0 +1,10 @@
+require 'mechanize'
+class WWW::Mechanize::Page
+  def links_to_other_documents(links_to_other_resources)
+    links_to_other_resources.map {|links_to_other_resource| get_attributes(links_to_other_resource.first,links_to_other_resource.last)}.flatten
+  end
+  
+  def get_attributes(tag,attribute)
+    (self/tag).map{|alink| alink.attributes[attribute]}.compact
+  end
+end

data/lib/magellan/extensions/string.rb

@@ -0,0 +1,21 @@
+require 'activesupport'
+require 'open-uri'
+class String
+  def to_absolute_url(origin_url)
+    begin
+      #BUG in URI.join?  URI.join('http://www.google.com/index.html?foo=b','?foo=a') # => http://www.google.com/?foo=a
+      stripped = self.strip
+      if stripped.starts_with?('?')
+        origin_url.gsub(/\?.*/,'') + stripped
+      else
+        URI.join(origin_url,stripped).to_s
+      end
+    rescue
+      self
+    end
+  end
+
+  def remove_fragment
+    self.gsub(/#.*/,'')
+  end
+end

data/lib/magellan/logger.rb

@@ -0,0 +1,8 @@
+module Magellan
+  class Logger
+    def update(time,result)
+      $stdout.putc(result ? '.' : 'F')
+      $stdout.flush
+    end
+  end
+end

data/lib/magellan/rake/base_magellan_task.rb

@@ -0,0 +1,40 @@
+
+#TODO: this is not a good place to use a template method - violates Liskov substitution principle
+module Magellan
+  module Rake
+    class BaseMagellanTask < ::Rake::TaskLib
+      attr_accessor :origin_url
+      attr_accessor :explore_depth
+      attr_accessor :ignored_urls
+
+      def initialize(name)
+        @ignored_urls = []
+        @name=name
+        yield self if block_given?
+        define
+      end
+
+      def define
+        desc description
+        task @name do
+          settings = {:origin_url => origin_url, :depth_to_explore => explore_depth, :domains => [origin_url], 
+                      :ignored_urls =>ignored_urls, :links_to_explore => links_to_explore, :trace => ENV['TRACE']}
+          cartographer = Magellan::Cartographer.new(settings)
+          observer = create_observer
+          observer.add_observer(Magellan::Logger.new)
+          cartographer.add_observer(observer)
+          cartographer.crawl
+          if observer.failed?
+            STDERR.puts observer.failure_message
+            exit 1
+          else
+            $stdout.puts "\n" + success_message
+          end
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/magellan/rake/broken_link_task.rb

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/tasklib'
+require 'magellan'
+require 'magellan/rake/base_magellan_task'
+
+module Magellan
+  module Rake
+    
+    class BrokenLinkTask < BaseMagellanTask
+      def initialize(name="magellan:explore")
+        super(name)
+      end
+      
+      def create_observer
+        Magellan::BrokenLinkTracker.new
+      end
+      
+      def links_to_explore
+        [["a","href"],["script","src"],["img","src"]]
+      end
+      
+      def description
+        "explore #{@origin_url} for broken links"
+      end
+      
+      def success_message
+        "No broken links were found!"
+      end
+      
+    end
+    
+  end
+end

data/lib/magellan/rake/expected_links_task.rb

@@ -0,0 +1,35 @@
+require 'rake'
+require 'rake/tasklib'
+require 'magellan'
+require 'magellan/rake/base_magellan_task'
+
+module Magellan
+  module Rake
+
+    class ExpectedLinksTask < BaseMagellanTask
+      attr_accessor :patterns_and_expected_links
+
+      def initialize(name="magellan:check_links")
+        super(name)
+      end
+
+      def description
+        "Explore #{@origin_url} and find check if all given patterns are matched"
+      end
+      
+      def links_to_explore
+        [["a","href"]]
+      end
+
+      def create_observer
+        Magellan::ExpectedLinksTracker.new(@patterns_and_expected_links)
+      end
+
+      def success_message
+        "All expected links found!"
+      end
+
+    end
+
+  end
+end

data/lib/magellan/result.rb

@@ -0,0 +1,20 @@
+module Magellan
+  class Result
+    attr_reader :status_code,:url,:destination_url,:linked_resources
+    def initialize(status_code,url,destination_url,linked_resources,content_type)
+      @status_code = status_code
+      @url = url
+      @destination_url = destination_url
+      @linked_resources = linked_resources
+      @content_type = content_type
+    end
+    
+    def absolute_linked_resources
+      absolute_links = linked_resources.map { |linked_resource| linked_resource.to_s.to_absolute_url(destination_url) }.compact
+    end
+    
+    def html_content?
+      @content_type.starts_with?("text/html")
+    end
+  end
+end

data/spec/array_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe "Array Extensions" do
+  it "should be able to break up a array into chunks with a max size" do
+    [1,2,3,4,5].chunk(3).size.should eql(2)
+    [1,2,3,4,5].chunk(3).first.should eql([1,2,3])
+    [1,2,3,4,5].chunk(3).last.should eql([4,5])
+  end
+  it "should be able to break up a array into chunks with a max size" do
+    [1,2,3,4,5].chunk(1).size.should eql(5)
+    [1,2,3,4,5].chunk(1).first.should eql([1])
+  end
+  
+end

data/spec/broken_link_task_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'rake'
+
+describe "Magellan BrokenLinkTask" do
+
+  before :all do
+    @file_name = File.dirname(__FILE__)  + "/../lib/magellan/rake/broken_link_task.rb"
+    @rake = Rake::Application.new
+    Rake.application = @rake
+  end
+
+  before :each do
+    load @file_name
+    $stdout.stubs(:putc)
+  end
+
+  after :all do
+    Rake.application = nil
+  end
+
+  it "should create a rake task" do
+    Magellan::Rake::BrokenLinkTask.new
+    tasks.include?("magellan:explore").should be_true
+  end
+  
+  it "should explore when task is invoked" do
+    Magellan::Rake::BrokenLinkTask.new("invoke_task") do |t|
+      t.explore_depth = 1
+      t.origin_url = "http://localhost:8080"
+    end
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with("http://localhost:8080").returns(create_result("http://localhost:8080","200"))
+    $stdout.expects(:puts) #passed message
+    @rake.invoke_task("invoke_task")
+  end
+
+  it "should raise exception when broken links are found" do
+    Magellan::Rake::BrokenLinkTask.new("exception_task") do |t|
+      t.explore_depth = 1
+      t.origin_url = "http://canrailsscale.com"
+    end
+    $stderr.expects(:puts)
+    Magellan::Explorer.any_instance.stubs(:explore_a).once.with("http://canrailsscale.com").returns(create_result("http://canrailsscale.com","500"))
+    lambda {@rake.invoke_task("exception_task")}.should raise_error
+  end
+  
+  it "should attach logger" do
+     Magellan::Rake::BrokenLinkTask.new("logger_test") do |t|
+       t.explore_depth = 1
+       t.origin_url = "http://canrailsscale.com"
+     end
+     $stderr.stubs(:puts)
+     Magellan::Logger.any_instance.expects(:update)
+     Magellan::Explorer.any_instance.stubs(:explore_a).once.with("http://canrailsscale.com").returns(create_result("http://canrailsscale.com","500"))
+     lambda {@rake.invoke_task("logger_test")}.should raise_error
+   end
+
+  def create_result(url,status_code)
+    Magellan::Explorer.create_result(url,url,status_code, [],"foo")
+  end
+
+  def tasks
+    @rake.tasks.collect{|task| task.name }
+  end
+end

data/spec/broken_link_tracker_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe Magellan::BrokenLinkTracker do
+
+  it "should not report broken links if there are none" do
+    broken_link_tracker = Magellan::BrokenLinkTracker.new
+    broken_link_tracker.update(Time.now,create_success_result('http://www.foo.com',['jalskdjflakjsf']))
+    broken_link_tracker.failed?.should be_false
+  end
+
+  it "should record links by absolute_url" do
+    broken_link_tracker = Magellan::BrokenLinkTracker.new
+    broken_link_tracker.update(Time.now,create_success_result('http://www.bozo.com/foople.html',['/apples.html']))
+    broken_link_tracker.update(Time.now,create_result('http://www.bozo.com/apples.html',"404",[]))
+    broken_link_tracker.failure_message.should  include("http://www.bozo.com/foople.html")
+  end
+
+  it "should only record broken links errors" do
+    broken_link_tracker = Magellan::BrokenLinkTracker.new
+    broken_link_tracker.update(Time.now,create_success_result('http://www.foo.com',['http://www.google.com']))
+    broken_link_tracker.update(Time.now,create_result('http://www.foo.com/404',"404",[]))
+    broken_link_tracker.failed?.should be_true
+    broken_link_tracker.broken_links.size.should eql(1)
+  end
+
+  it "should record 4** errors" do
+    broken_link_tracker = Magellan::BrokenLinkTracker.new
+    broken_link_tracker.update(Time.now,create_result('http://www.foo.com/404',"404",[]))
+    broken_link_tracker.broken_links.first.status_code.should eql('404')
+  end
+  
+  it "have url and status code in the error message" do
+    broken_link_tracker = Magellan::BrokenLinkTracker.new
+    broken_link_tracker.update(Time.now,create_result('broke url',"404",[]))
+    broken_link_tracker.failure_message.should include('broke url')
+    broken_link_tracker.failure_message.should include("404")
+  end
+  
+  it "should record 5** errors" do
+    broken_link_tracker = Magellan::BrokenLinkTracker.new
+    broken_link_tracker.update(Time.now,create_result('fooz',"500",[]))
+    broken_link_tracker.broken_links.first.status_code.should eql('500')
+  end
+  
+  def create_success_result(url,linked_resources)
+    create_result(url,"200",linked_resources)
+  end
+  
+  def create_result(url,status_code, linked_resources)
+    Magellan::Result.new(status_code,url,url,linked_resources,"foo")
+  end
+  
+  it "should update the observer with a pass" do
+    tracker = Magellan::BrokenLinkTracker.new
+    tracker.add_observer(Magellan::Logger.new)
+    $stdout.expects(:putc).with('.')
+    tracker.update(Time.now,Magellan::Result.new('200','/zoro','/zoro',['/about_us.html'],"text/html")) 
+  end
+  
+  it "should update the observer with a pass" do
+    tracker = Magellan::BrokenLinkTracker.new
+    tracker.add_observer(Magellan::Logger.new)
+    $stdout.expects(:putc).with('F')
+    tracker.update(Time.now,Magellan::Result.new('404','/zoro','/zoro',['/fail_about_us.html'],"text/html")) 
+  end
+end

data/spec/cartographer_spec.rb

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe Magellan::Cartographer do
+
+  it "should not visit the same url more then once" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(['http://www.google.com']))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.crawl
+  end
+  
+  it "should not visit the origin url more then once if it finds a link with a finishing /" do
+    pending
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(['http://www.google.com/']))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.crawl
+  end
+  
+  it "should try to explore urls in the domain we care about that have non ascii characters in them" do
+    origin_url = "http://www.reddit.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(["http://www.reddit.com/r/science/comments/87dk7/cold_fusion_is_a_pipe_dream_but_μcatalyzed_cool/","http://www.domainwedontcareabout.com/μ"]))
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with("http://www.reddit.com/r/science/comments/87dk7/cold_fusion_is_a_pipe_dream_but_μcatalyzed_cool/").returns(create_success_result([]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.crawl
+  end
+  
+  it "should not visit the same url more then once if they differ by fragment id" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(['http://www.google.com#foo']))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.crawl
+  end
+  
+  it "should notify observers when a result comes in" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(['http://www.google.com']))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    foo = Object.new
+    foo.expects(:update)
+    cartographer.add_observer(foo)
+    cartographer.crawl
+  end
+  
+  it "should notify observers everytime a result comes in" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(['http://www.google.com/foo.html','http://www.google.com/bar.html']))
+    Magellan::Explorer.any_instance.expects(:explore_a).with('http://www.google.com/foo.html').returns(create_success_result([]))
+    Magellan::Explorer.any_instance.expects(:explore_a).with('http://www.google.com/bar.html').returns(create_success_result([]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    foo = Object.new
+    foo.expects(:update).times(3)
+    cartographer.add_observer(foo)
+    cartographer.crawl
+  end
+
+  it "should explore other linked resources" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).with(origin_url).returns(create_success_result(['http://www.google.com/foo.html']))
+    Magellan::Explorer.any_instance.expects(:explore_a).with('http://www.google.com/foo.html').returns(create_success_result([]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.crawl
+  end
+  
+  it "should not explore ignored urls" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).with(origin_url).returns(create_success_result(['http://www.google.com/foo.html','http://www.google.com/ignoreme.html']))
+    Magellan::Explorer.any_instance.expects(:explore_a).with('http://www.google.com/foo.html').returns(create_success_result([]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url,3,[origin_url],['http://www.google.com/ignoreme.html']))
+    cartographer.crawl
+  end
+  
+  it "should not explore the same url more then once" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).with(origin_url).returns(create_success_result(['http://www.google.com/foo.html','http://www.google.com/foo.html']))
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with('http://www.google.com/foo.html').returns(create_success_result([]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.crawl
+  end
+  
+  it "should be able to specify crawlable domains" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(['http://www.foo.com']))
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with('http://www.foo.com').returns(create_success_result(['http://www.bar.com']))
+    cartographer = Magellan::Cartographer.new(settings(origin_url, 5,['http://www.google.com','http://www.foo.com']))
+    cartographer.crawl
+  end
+
+  it "should explore relative links" do
+     origin_url = "http://www.google.com"
+     Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(['http://www.google.com/foo.html']))
+     Magellan::Explorer.any_instance.expects(:explore_a).once.with('http://www.google.com/foo.html').returns(create_success_result(['/foo2.html']))
+     Magellan::Explorer.any_instance.expects(:explore_a).once.with('http://www.google.com/foo2.html').returns(create_success_result([]))
+     cartographer = Magellan::Cartographer.new(settings(origin_url))
+     cartographer.crawl
+   end
+
+  it "should go n layers deep into a site" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(['http://www.google.com/foo.html']))
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with('http://www.google.com/foo.html').returns(create_success_result(['http://www.google.com/foo2.html']))
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with('http://www.google.com/foo2.html').returns(create_success_result(['http://www.google.com/foo3.html']))
+    cartographer = Magellan::Cartographer.new(settings(origin_url,3))
+    cartographer.crawl
+  end
+
+  it "should use host to determine if we are in a allowed domain" do
+    origin_url = "http://www.google.com/jskfjlsajfd"
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.a_domain_we_care_about?("http://www.google.com/index.html").should be_true
+  end
+  
+  it "should not explore js urls and print warnings if they are found, obtrusive javascript is bad mmkay" do
+    origin_url = "http://www.google.com"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(["javascript:bookmarksite('ThoughtWorks Studios', 'http://studios.thoughtworks.com')",'http://www.google.com/foo']))
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with('http://www.google.com/foo').returns(create_success_result([]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.crawl
+  end
+  
+  #<a alex.hal9000@gmail.com="" href="mailto:PWang@thoughtworks.com,">PWang@thoughtworks.com, alex.hal9000@gmail.com</a>
+  
+  it "should not die on checking the domain on invalid urls" do
+    origin_url = "http://www.google.com/adsfaf"
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.a_domain_we_care_about?("mailto:PWang@thoughtworks.com,").should be_false
+  end
+  
+  it "should not explore mailto urls" do
+    origin_url = "http://www.google.com/adsfaf"
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with(origin_url).returns(create_success_result(["mailto:foo"]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url))
+    cartographer.crawl
+  end
+  
+  it "should puts out urls if the trace is enabled" do
+    origin_url = "http://www.google.com/adsfaf"
+    Magellan::Explorer.any_instance.stubs(:explore_a).once.with(origin_url).returns(create_success_result([]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url).merge( {:trace=> true}))
+    $stdout.expects(:puts).with {|value| value.include?(origin_url)}
+    cartographer.crawl
+  end
+  
+  it "should not puts if the trace is disabled" do
+    origin_url = "http://www.google.com/adsfaf"
+    Magellan::Explorer.any_instance.stubs(:explore_a).once.with(origin_url).returns(create_success_result([]))
+    cartographer = Magellan::Cartographer.new(settings(origin_url).merge( {:trace=> false}))
+    $stdout.expects(:puts).never
+    cartographer.crawl
+  end
+   
+  it "should record the source and the destination url in known urls" do
+    origin_url = "http://studios.thoughtworks.com/cruise"
+    cartographer = Magellan::Cartographer.new(settings(origin_url, 1))
+    cartographer.crawl
+    cartographer.i_have_seen_this_url_before?(origin_url).should be_true
+    cartographer.i_have_seen_this_url_before?("http://studios.thoughtworks.com/cruise-continuous-integration").should be_true
+  end
+  
+  it "should go through a entire site if layers to explore is set to -1"
+  it "should explore n layers into external domains"
+  
+  def create_success_result(linked_resources)
+    create_result("200",linked_resources)
+  end
+  
+  def settings(origin_url,depth=5,domains = [origin_url], ignored_urls=[])
+    {:origin_url => origin_url, :depth_to_explore => depth, :domains => domains, :ignored_urls =>ignored_urls, :links_to_explore => [["a","href"]] }
+  end
+  
+  def create_result(status_code, linked_resources)
+    Magellan::Result.new(status_code,"http://www.google.com","http://www.google.com",linked_resources,"text/html")
+  end
+  
+end

data/spec/expected_links_task_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'rake'
+
+describe "Magellan ExpectedLinksTask" do
+
+  before :all do
+    @file_name = File.dirname(__FILE__)  + "/../lib/magellan/rake/expected_links_task.rb"
+    @rake = Rake::Application.new
+    Rake.application = @rake
+  end
+
+  before :each do
+    $stdout.stubs(:putc)
+    load @file_name
+  end
+
+  after :all do
+    Rake.application = nil
+  end
+
+  it "should create a rake task" do
+    Magellan::Rake::ExpectedLinksTask.new
+    tasks.include?("magellan:check_links").should be_true
+  end
+
+  it "should explore when task is invoked" do
+    Magellan::Rake::ExpectedLinksTask.new("some_task") do |t|
+      t.explore_depth = 1
+      t.patterns_and_expected_links = []
+      t.origin_url = "http://localhost:8080"
+    end
+    $stdout.expects(:puts)
+    Magellan::Explorer.any_instance.expects(:explore_a).once.with("http://localhost:8080").returns(create_result("http://localhost:8080","200"))
+    @rake.invoke_task("some_task")
+  end
+  
+  
+  it "should notify a expected link tracker when a task is invoked" do
+    Magellan::Rake::ExpectedLinksTask.new("invoke_expected_link_tracker") do |t|
+      t.explore_depth = 1
+      t.patterns_and_expected_links = []
+      t.origin_url = "http://localhost:8080"
+    end
+    $stdout.expects(:puts)
+    Magellan::Explorer.any_instance.stubs(:explore_a).once.with("http://localhost:8080").returns(create_result("http://localhost:8080","200"))
+    Magellan::ExpectedLinksTracker.any_instance.expects(:update).once
+    @rake.invoke_task("invoke_expected_link_tracker")
+  end
+  
+  it "should fail the rake task if expected links did not exist or rules did not evaluate to be true" do
+    Magellan::Rake::ExpectedLinksTask.new("exception_raising_task") do |t|
+      t.explore_depth = 1
+      t.patterns_and_expected_links = [[/.*/,'/about_us.html']]
+      t.origin_url = "http://canrailsscale.com"
+    end
+    $stderr.expects(:puts)
+    Magellan::Explorer.any_instance.stubs(:explore_a).once.with("http://canrailsscale.com").returns(create_result("http://canrailsscale.com","200"))
+    lambda {@rake.invoke_task("exception_raising_task")}.should raise_error
+  end
+  
+  def create_result(url,status_code)
+    Magellan::Explorer.create_result(url,url,status_code, [],"text/html")
+  end
+
+  def tasks
+    @rake.tasks.collect{|task| task.name }
+  end
+end

data/spec/expected_links_tracker_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe Magellan::ExpectedLinksTracker do
+
+  it "should create a error message contianing the offending url and " do
+    tracker = Magellan::ExpectedLinksTracker.new([[/.*/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/fozo',"/bar",[],"text/html"))
+    tracker.errors.first.should include('/fozo')
+    tracker.errors.first.should include('/about_us.html')
+  end
+
+  it "should be able specify all resource should link to something" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/.*/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/zoro','/zoro',['/about_us.html'],"text/html"))
+    tracker.has_errors?.should be_false
+    tracker.update(Time.now,Magellan::Result.new('200','/zoro','/zoro',['/about_fail_us.html'],"text/html"))
+    tracker.has_errors?.should be_true
+  end
+  
+  it "should only apply rules if they apply to source url" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/foo\.html/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/zoro','/zoro',['/about_fail_us.html'],"text/html"))
+    tracker.has_errors?.should be_false
+    tracker.update(Time.now,Magellan::Result.new('200','/foo.html','/zoro',['/about_fail_us.html'],"text/html"))
+    tracker.has_errors?.should be_true
+  end
+
+  it "should only apply rules if they apply to destination url" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/foo\.html/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/zooo','/zoro',['/about_fail_us.html'],"text/html"))
+    tracker.has_errors?.should be_false
+    tracker.update(Time.now,Magellan::Result.new('200','/zooo','/foo.html',['/about_fail_us.html'],"text/html"))
+    tracker.has_errors?.should be_true
+  end
+  
+  it "should know if a expectation was never met" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/foo\.html/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/zooo','/zoro',['/about_fail_us.html'],"text/html"))
+    tracker.unmet_expecations?.should be_true
+    tracker.update(Time.now,Magellan::Result.new('200','/foo.html','/foo.html',['/about_fail_us.html'],"text/html"))
+    tracker.unmet_expecations?.should be_false
+  end
+  
+  it "should provide a meaningfull error message around unmet expectations" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/foo\.html/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/zooo','/zoro',['/about_fail_us.html'],"text/html"))
+    tracker.unmet_expecations_messages.should include(/foo\.html/.to_s)
+  end
+  
+  it "should return failed if there are unmet expectations" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/foo\.html/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/zooo','/zoro',['/about_fail_us.html'],"text/html"))
+    tracker.failed?.should be_true
+    tracker.update(Time.now,Magellan::Result.new('200','/foo.html','/zoro',['/about_us.html'],"text/html"))
+    tracker.failed?.should be_false
+  end
+
+  it "should return failed if there are failed expectations" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/.*/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/zoro','/zoro',['/about_us.html'],"text/html")) 
+    tracker.failed?.should be_false
+    tracker.update(Time.now,Magellan::Result.new('200','/fozo',"/bar",[],"text/html"))
+    tracker.failed?.should be_true
+  end
+
+  it "should ignore the result if it is not a html content type" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/.*/,'/about_us.html']])
+    tracker.update(Time.now,Magellan::Result.new('200','/zoro','/zoro',['/about_us.html'],"text/html")) 
+    tracker.update(Time.now,Magellan::Result.new('200','/fozo',"/bar",[],"application/javascript"))
+    tracker.failed?.should be_false
+  end
+
+  it "should update the observer with a pass" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/.*/,'/about_us.html']])
+    tracker.add_observer(Magellan::Logger.new)
+    $stdout.expects(:putc).with('.')
+    tracker.update(Time.now,Magellan::Result.new('200','/zoro','/zoro',['/about_us.html'],"text/html")) 
+  end
+  it "should update the observer with a pass" do
+    tracker = Magellan::ExpectedLinksTracker.new([[/.*/,'/about_us.html']])
+    tracker.add_observer(Magellan::Logger.new)
+    $stdout.expects(:putc).with('F')
+    tracker.update(Time.now,Magellan::Result.new('200','/zoro','/zoro',['/fail_about_us.html'],"text/html")) 
+  end
+
+end

data/spec/explorer_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe Magellan::Explorer do
+
+  it "should find other js resources" do
+    result = Magellan::Explorer.new(['http://canrailsscale.com/'],links_to_explore).explore
+    result.first.absolute_linked_resources.should include('http://pagead2.googlesyndication.com/pagead/show_ads.js')
+  end
+  
+  it "should foo" do
+    WWW::Mechanize.any_instance.expects(:get).raises(Timeout::Error)
+    result = Magellan::Explorer.new(['http://canrailsscale.com/'],links_to_explore).explore
+    result.first.status_code.should eql('505')
+    result.first.url.should eql('http://canrailsscale.com/')
+  end
+
+  it "should have one result for one url" do
+    result = Magellan::Explorer.new(['http://www.google.com/'],links_to_explore).explore
+    result.size.should eql(1)
+  end
+
+  it "should have two results for two urls" do
+    result = Magellan::Explorer.new(['http://www.google.com/','http://www.apple.com/'],links_to_explore).explore
+    result.size.should eql(2)
+  end
+
+  it "should find other pages to explore via a href" do
+    result = Magellan::Explorer.new('http://www.google.com/',links_to_explore).explore
+    result.first.absolute_linked_resources.should include('http://video.google.com/?hl=en&tab=wv')
+  end
+
+  it "should translate relative urls to absolute ones" do
+    result = Magellan::Explorer.new('http://www.google.com/',links_to_explore).explore
+    result.first.absolute_linked_resources.should include('http://www.google.com/intl/en/about.html')
+  end
+
+  it "should report non successful status codes" do
+    result = Magellan::Explorer.new('http://www.google.com/dfkjaslfkjaslfkj.html',links_to_explore).explore
+    result.first.status_code.should eql("404")
+  end
+
+  it "should not get any links if it not a text/xhtml file" do
+    result = Magellan::Explorer.new("http://jqueryjs.googlecode.com/files/jquery-1.3.2.min.js",links_to_explore).explore
+    result.first.absolute_linked_resources.should be_empty
+  end
+
+  it "should update url if redirected" do
+    result = Magellan::Explorer.new("http://www.thoughtworks.com/mingle",links_to_explore).explore
+    result.first.destination_url.should eql("http://studios.thoughtworks.com/mingle-agile-project-management")
+  end
+
+  it "should return source url as desintation url if a error occurs" do
+    result = Magellan::Explorer.new("http://www.google.com/dfkjaslfkjaslfkj.html",links_to_explore).explore
+    result.first.destination_url.should eql("http://www.google.com/dfkjaslfkjaslfkj.html")
+  end
+
+  it "should be able to explore a url" do
+    Magellan::Explorer.new('',links_to_explore).explore_a("http://www.yahoo.com")
+  end
+
+  it "should be able to go from http to https" do
+    result = Magellan::Explorer.new("http://mail.yahoo.com",links_to_explore).explore
+    result.first.destination_url.starts_with?("https://").should be_true
+  end
+  
+  it "should be able to crawl ftp based links"
+
+  def links_to_explore
+    [["a","href"],["script","src"],["img","src"]]
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe Magellan::Logger do
+  it "should put a . for a pass" do
+    logger = Magellan::Logger.new
+    $stdout.expects(:putc).with('.')
+    logger.update(Time.now,true)
+  end
+  it "should put a F for a fail" do
+    logger = Magellan::Logger.new
+    $stdout.expects(:putc).with('F')
+    logger.update(Time.now,false)
+  end
+end

data/spec/mechanize_page_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe "WWW::Mechanize::Page Extensions" do
+  LINKS = [["a","href"],["script","src"],["img","src"]]
+
+  it "should not return nil for script tags without src attritubes" do
+    doc = WWW::Mechanize::Page.new(nil,{'content-type' => "text/html"},"<script class=foo>something</script>")
+    doc.links_to_other_documents(LINKS).should be_empty
+  end
+  
+  it "should find links based on script tags with src attritubes" do
+    doc = WWW::Mechanize::Page.new(nil,{'content-type' => "text/html"},"<script class=foo src='foozor'>something</script>")
+    links_to_other_documents = doc.links_to_other_documents(LINKS)
+    links_to_other_documents.size.should eql(1)
+    links_to_other_documents.first.to_s.should eql("foozor")
+  end
+
+  it "should be able to get two script sources" do
+    doc = WWW::Mechanize::Page.new(nil,{'content-type' => "text/html"},"<body><script class=foo src='foozor'>something</script><script class=foo src='fdsajfkajf'>something</script></body>")
+    links_to_other_documents = doc.links_to_other_documents(LINKS)
+    links_to_other_documents.size.should eql(2)
+  end
+
+  it "should find links based on a tags with href attritubes" do
+    doc = WWW::Mechanize::Page.new(nil,{'content-type' => "text/html"},"<a class=foo href='bozo'>something</a>")
+    links_to_other_documents = doc.links_to_other_documents(LINKS)
+    links_to_other_documents.size.should eql(1)
+    links_to_other_documents.first.to_s.should eql("bozo")
+  end
+
+  it "should find links based on img tags with src attritubes" do
+    doc = WWW::Mechanize::Page.new(nil,{'content-type' => "text/html"},"<img class=foo src='ohno' alt='whatever' />")
+    links_to_other_documents = doc.links_to_other_documents(LINKS)
+    links_to_other_documents.size.should eql(1)
+    links_to_other_documents.first.to_s.should eql("ohno")
+  end
+
+  it "should links based on a tags with href attritubes" do
+    doc = WWW::Mechanize::Page.new(nil,{'content-type' => "text/html"},"<a class=foo>something</a>")
+    doc.links_to_other_documents(LINKS).should be_empty
+  end
+  
+end

data/spec/result_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe Magellan::Result do
+
+  it "should not remove fragments when converting to absolute urls" do
+    results = Magellan::Result.new("200","http://www.google.com/index.html","http://www.google.com/index.html",["/index.html#foo"],"foo")
+    results.absolute_linked_resources.should include("http://www.google.com/index.html#foo")
+  end
+
+  it "should use destination_url to build new absolute urls" do
+    results = Magellan::Result.new("200","http://www.google.com/bob.html","http://www.foo.com/bob.html",["/index.html"],"foo")
+    results.absolute_linked_resources.should include("http://www.foo.com/index.html")
+  end
+
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'spec'
+require 'mocha'
+require File.dirname(__FILE__) + '/../config/vendorized_gems'
+
+lib_path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end

data/spec/string_extensions_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'magellan'
+
+describe "String Extensions" do
+  
+  it "should convert relative urls to absolute" do
+    input = '/Test_Automation_Framework/chrome/common/js/trac.js'
+    input.to_absolute_url('http://www.google.com').should eql('http://www.google.com/Test_Automation_Framework/chrome/common/js/trac.js')
+  end
+
+  it "should remove any relative path from original url" do
+    input = '/foo/trac.js'
+    input.to_absolute_url('http://www.google.com/something/index.html').should eql('http://www.google.com/foo/trac.js')
+  end
+
+  it "should merge urls correctly with dots" do
+    input = '../foo/trac.js'
+    input.to_absolute_url('http://www.google.com/something/index.html').should eql('http://www.google.com/foo/trac.js')
+  end
+
+  it "should do nothing to absolute http urls" do
+    input = 'http://www.apple.com'
+    input.to_absolute_url('http://www.google.com').should eql('http://www.apple.com')
+  end
+  
+  it "should not put double slashes when converting absolute to relative" do
+    input = "/intl/en/about.html"
+    input.to_absolute_url('http://www.google.com/').should eql('http://www.google.com/intl/en/about.html')
+  end
+  
+  it "should do nothing to absolute https urls" do
+    input = 'https://www.apple.com'
+    input.to_absolute_url('http://www.google.com').should eql('https://www.apple.com')
+  end
+  
+  it "should translate relative https urls to absolute" do
+    input = "/intl/en/about.html"
+    input.to_absolute_url('https://www.google.com/').should eql('https://www.google.com/intl/en/about.html')
+  end
+  
+  it "should translate relative urls to absolute ones" do
+    "/intl/en/about.html".to_absolute_url("http://www.google.com").should eql('http://www.google.com/intl/en/about.html')
+  end
+
+  it "should not translate absolute urls" do
+    "http://video.google.com/foo/about.html".to_absolute_url("http://www.google.com").should eql("http://video.google.com/foo/about.html")
+  end
+  
+  it "should return string itself if uri parse fails" do
+    "something not a url".to_absolute_url("http://www.google.com").should eql("something not a url")
+  end
+  
+  it "should chomp the fragment portion off the url" do
+    "http://video.google.com/foo/about.html#sdkfjskajflsajf".remove_fragment.should eql("http://video.google.com/foo/about.html")
+  end
+  
+  it "should strip spaces off of the input url" do
+    input = ' http://www.apple.com'
+    input.to_absolute_url('http://www.google.com').should eql('http://www.apple.com')
+  end
+  
+  it "should correctly join urls that are stricktly query params" do 
+    input = '?foo=bar'
+    input.to_absolute_url('http://www.google.com/index.html?foo=zoro').should eql('http://www.google.com/index.html?foo=bar')
+  end
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: magellan
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Nolan Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: TODO
+email: nolane@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- VERSION.yml
+- lib/magellan
+- lib/magellan/broken_link_tracker.rb
+- lib/magellan/cartographer.rb
+- lib/magellan/expected_links_tracker.rb
+- lib/magellan/explorer.rb
+- lib/magellan/extensions
+- lib/magellan/extensions/array.rb
+- lib/magellan/extensions/mechanize_page.rb
+- lib/magellan/extensions/string.rb
+- lib/magellan/logger.rb
+- lib/magellan/rake
+- lib/magellan/rake/base_magellan_task.rb
+- lib/magellan/rake/broken_link_task.rb
+- lib/magellan/rake/expected_links_task.rb
+- lib/magellan/result.rb
+- lib/magellan.rb
+- spec/array_spec.rb
+- spec/broken_link_task_spec.rb
+- spec/broken_link_tracker_spec.rb
+- spec/cartographer_spec.rb
+- spec/expected_links_task_spec.rb
+- spec/expected_links_tracker_spec.rb
+- spec/explorer_spec.rb
+- spec/logger_spec.rb
+- spec/mechanize_page_spec.rb
+- spec/result_spec.rb
+- spec/spec_helper.rb
+- spec/string_extensions_spec.rb
+- README
+has_rdoc: true
+homepage: http://github.com/nolman/magellan
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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: magellan
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A web testing framework that embraces the discoverable nature of the web
+test_files: []
+