feedisco 0.1.1

data/Gemfile

@@ -0,0 +1,11 @@
+source 'http://rubygems.org'
+
+gem 'nokogiri'
+
+group :development do
+  gem 'jeweler'
+end
+
+group :test do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.5)
+    nokogiri (1.5.5)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  nokogiri
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Romain Champourlier <romain@softr.li>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# Feedisco
+
+### Summary
+
+Feedisco is a small and lightweight library focused on RSS/Atom feed discovery. It is intended to do little, but to do it well!
+
+### Use case(s)
+
+* I want to **find the URLs of a RSS/Atom feeds for my users' blogs**
+* I want to **check that an user-supplied URL is truly a RSS/Atom feed URL**
+* I want to let my user **choose from a list of discovered RSS/Atom feeds** when he entered his website URL
+* Probably more...
+
+### The methods
+
+```
+Feedisco.find(url)
+Feedisco.feed?(url)
+```
+
+### How to start
+
+**Install it with Rubygems**
+
+```
+$ gem install feedisco
+$ irb
+
+irb(main):001:0> require 'rubygems'
+=> true
+irb(main):001:0> require 'feedisco'
+=> true
+```
+
+**...or clone it from GitHub**
+
+```
+$ git clone https://github.com/rchampourlier/feedisco
+$ cd feedisco
+$ bundle install
+$ bundle exec script/console
+```
+
+_**Nota Bene:**_
+
+* _`script/console` is a small script available in the repo that loads an IRB/Pry console with Feedisco preloaded, so it's ready to use! (feel like `rails console`)_
+
+### Examples
+
+```
+irb(main):001:0> Feedisco.find('rchampourlier.com')
+=> ["http://feeds.rchampourlier.com/rchampourlier"]
+
+irb(main):002:0> Feedisco.find('google.com')
+=> []
+
+irb(main):003:0> Feedisco.feed?('google.com')
+=> false
+
+irb(main):007:0> Feedisco.feed?('feeds.rchampourlier.com/rchampourlier')
+=> true
+
+irb(main):010:0> puts Feedisco.find('http://edition.cnn.com/services/rss/')
+http://rss.cnn.com/rss/edition.rss
+http://rss.cnn.com/rss/edition_asia.rss
+http://rss.cnn.com/rss/edition_europe.rss
+http://rss.cnn.com/rss/edition_us.rss
+http://rss.cnn.com/rss/edition_world.rss
+http://rss.cnn.com/rss/edition_africa.rss
+http://rss.cnn.com/rss/edition_americas.rss
+[and a lot more...]
+```
+
+### Installation
+
+Add this to your Gemfile (the gem is not published to Rubygems until it is good enough, so tell me when you think it should!):
+
+```
+gem 'feedisco', :git => 'https://github.com/rchampourlier/feedisco', :ref => 'master'
+```
+
+Or just clone it and do whatever you want:
+
+```
+$ git clone http://github.com/rchampourlier/feedisco
+```
+
+
+### Why should you use it?
+
+* Well, because you need to discover feeds URL from a given URL, and nothing more!
+* Because you wan't it to be simple, with clean-code you can correct, complete, update, test, if you need it.
+* Because you just need to add a line to your Gemfile to use it.
+* Because it should still follow modern feed filename conventions (like those ones used by WordPress blogs, or Blogger, etc) - that's the part taken from [Feedbag](https://github.com/damog/feedbag)!
+
+### Why did I build it?
+
+* Because I wanted a **simple and lightweight** library to discover RSS/Atom feeds.
+* Because [Feedbag](https://github.com/damog/feedbag) was using Hpricot, and I was more Nokogiri.
+* Because I wanted something with a little more tests than Feedbag.
+
+### Bugs, issues, contributions
+
+You can use the [GitHub repo](https://github.com/rchampourlier/feedisco) for all this, so don't hesitate!
+
+Contribute by forking, tweaking, and sending pull requests, but please add the appropriate tests!
+
+### History
+
+#### `0.1.1`
+
+* Completed `Rakefile`
+* Changed a method from private to public, specs are green again
+
+#### `0.1.0`
+
+* Initial release
+
+### Author
+
+[Romain Champourlier](http://softr.li)
+
+### Copyright
+
+This is free software. See [LICENSE](http://github.com/rchampourlier/feedisco/master/LICENSE) for more information.
+
+### Thanks
+
+[David Moreno](http://damog.net/) for [Feedbag](https://github.com/damog/feedbag) which I used before writing Feedisco. Plus Feedisco is more than inspired from Feedbag, even if I almost rewrote everything to make (to my sense) more Ruby-way, readable, and in particular more tested.

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "feedisco"
+  gem.summary = "A simple feed discovery library"
+  gem.description = "Feedisco is a small and lightweight library focused on RSS/Atom feed discovery. It is intended to do little, but to do it well!"
+  gem.email = "romain@softr.li"
+  gem.homepage = "http://github.com/rchampourlier/feedisco"
+  gem.authors = ["Romain Champourlier"]
+  gem.license = "MIT"
+  gem.add_dependency 'nokogiri'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "oro #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/feedisco.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "feedisco"
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Romain Champourlier"]
+  s.date = "2012-09-28"
+  s.description = "Feedisco is a small and lightweight library focused on RSS/Atom feed discovery. It is intended to do little, but to do it well!"
+  s.email = "romain@softr.li"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "feedisco.gemspec",
+    "lib/feedisco.rb",
+    "lib/feedisco/checks.rb",
+    "lib/feedisco/discovery.rb",
+    "lib/feedisco/utilities.rb",
+    "lib/feedisco/version.rb",
+    "script/console",
+    "spec/fixtures/alternate.html",
+    "spec/fixtures/no_link.html",
+    "spec/fixtures/one_link_in_body.html",
+    "spec/fixtures/several_links.html",
+    "spec/lib/checks_spec.rb",
+    "spec/lib/discovery_spec.rb",
+    "spec/lib/utilities_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/rchampourlier/feedisco"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "A simple feed discovery library"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
+    else
+      s.add_dependency(%q<nokogiri>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<nokogiri>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<nokogiri>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<nokogiri>, [">= 0"])
+  end
+end
+

data/lib/feedisco/checks.rb

@@ -0,0 +1,50 @@
+module Feedisco::Checks
+
+  # Check if the specified URL is a feed URL. The check is performed by opening the
+  # URL and checking the content type. If it matches a content type within
+  # Feedisco.feed_content_types, the URL is considered as a feed and the method returns
+  # true.
+  def feed?(url)
+    feed_content_type?(url)
+  end
+
+  # Determines if the specified URL looks like a feed. We consider it does if:
+  #   - it ends with a 'feed-suffix': .rdf, .xml, .rss
+  #   - it contains a 'feed=rss' or 'feed=atom' query param (well, we don't check
+  #     if it is really a query param, as long as it is in the URL)
+  #   - it ends with 'atom' or 'feed' (with or without the '/' at the end)
+  def looks_like_feed?(url)
+    (url =~ %r{(\.(rdf|xml|rss)$|feed=(rss|atom)(&(.)+)?$|(atom|feed)/?$)}i) != nil
+  end
+
+  private
+
+  # Open the specified URL and check its content type. Returns true if the content type
+  # is a feed content type (in Feedisco.feed_content_types)
+  # 
+  # You can pass an URL (a string) or a file (open(...), a Tempfile instance) to the method.
+  def feed_content_type?(url_or_file)    
+    opened = false
+
+    if url_or_file.is_a? String
+      harmonized_url = harmonize_url(url_or_file)
+      file = open(harmonized_url)
+      opened = true
+    
+    elsif url_or_file.class.to_s == 'Tempfile'
+      file = url_or_file
+    
+    else raise ArgumentError.new('argument must be a String (url) or a Tempfile created with `open(url)`')
+    end
+
+    # Retrieve page content type
+    content_type = file.content_type.downcase
+    if content_type == "application/octet-stream"
+      content_type = file.meta["content-type"].gsub(/;.*$/, '')
+    end
+    file.close if opened
+
+    # Check if the content-type indicates RSS/Atom feed (in Feedisco.feed_content_types)
+    Feedisco.feed_content_types.include?(content_type)
+  end
+end

data/lib/feedisco/discovery.rb

@@ -0,0 +1,57 @@
+require 'feedisco/utilities'
+require 'feedisco/checks'
+
+module Feedisco
+  extend Checks
+  extend Utilities
+
+  module Discovery
+    
+    # Find RSS/Atom feed URLs by looking around the specified URL.
+    def find(url, args = {})
+      raise ArgumentError.new("url can't be nil!") if url.nil?
+      
+      harmonized_url = harmonize_url(url)
+
+      raise ArgumentError.new("url's protocol must be 'http(s)' or 'feed' (#{url})") if harmonized_url.nil?
+
+      feeds = []
+
+      # Open the URL to check the content-type or crawl for feed links
+      open(harmonized_url) do |file|
+
+        if feed_content_type?(file)
+          # Add the url to feeds if it shows a feed content type
+          feeds << harmonized_url
+        
+        else
+          # Else, parse the page to search for links
+          doc = Nokogiri::HTML(file.read)
+
+          # Check <link> elements
+          doc.css('link').each do |link|
+            feeds << complete_extracted_url(link[:href], harmonized_url) if link[:rel] =~ %r{(alternate|service.feed)}i && Feedisco.feed_content_types.include?(link[:type].downcase.strip)
+          end
+
+          # Check <a> elements
+          doc.css('a').each do |a|
+            if (looks_like_feed?(a[:href]) &&
+               (a[:href] =~ %r{\A/} || a[:href] =~ %r{#{URI.parse(harmonized_url).host}/}) &&
+               !feeds.include?(a[:href]))
+
+              feeds << complete_extracted_url(a[:href], harmonized_url)
+            end
+          end
+
+          # Check <a> elements again, less restrictively, so we add all discovered feeds even the ones
+          # on external domains, but the will come after in the feeds array.
+          doc.css('a').each do |a|
+            feeds << complete_extracted_url(a[:href], harmonized_url) if (looks_like_feed?(a[:href]) && !feeds.include?(a[:href]))
+          end
+        end
+      end
+
+      feeds
+    end
+  end
+end

data/lib/feedisco/utilities.rb

@@ -0,0 +1,46 @@
+module Feedisco::Utilities
+
+  # Check the specified URL protocol. To be considered as a valid feed URL, it must
+  # match either 'feed', 'http', or 'https', or be nil. If it does, the url is returned
+  # with 'http' or 'https' protocol (replacing nil and 'feed' ones). Else, it returns nil.
+  def harmonize_url(url)
+    url_uri = URI.parse(url)
+
+    case url_uri.scheme
+    when nil
+      "http://#{url}"
+
+    when 'feed'
+      url.sub(%r{feed://}, 'http://')
+    
+    when %r{http(s)?}
+      url
+
+    else
+      nil
+    end
+  end
+
+  # Complete extracted_url with page_url:
+  #   - if extracted_url is relative, completes it with the protocol,
+  #     host and path from page_url (page_url is expected to be absolute!)
+  #   - just returns extracted_url if it is absolute.
+  def complete_extracted_url(extracted_url, page_url)
+    extracted_uri = URI.parse(extracted_url)
+    page_uri = URI.parse(page_url)
+
+    if extracted_uri.absolute?
+      extracted_url 
+
+    else
+      raise ArgumentError.new('page_url must be absolute if extracted_url isn\'t!') unless page_uri.absolute?
+
+      if extracted_url =~ %r{\A/}
+        # Starts with '/', root of page_url's domain
+        "#{page_uri.scheme}://#{page_uri.host}#{extracted_url}"
+      else
+        "#{page_uri.scheme}://#{page_uri.host}#{page_uri.path}/#{extracted_url}"
+      end
+    end
+  end
+end

data/lib/feedisco/version.rb

@@ -0,0 +1,6 @@
+class Feedisco
+
+  def version
+    '0.1.1'
+  end
+end

data/lib/feedisco.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/ruby
+
+# Feedisco
+#
+# Built from Feedbag
+#   - replaced Hpricot by Nokogiri
+# 	- improved discovery to check on /rss and /atom URIs
+# 	- removed the global variables
+#
+# Copyright  Axiombox (c) 2008
+#            David Moreno <david@axiombox.com> (c) 2008
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require "rubygems"
+require "nokogiri"
+require "open-uri"
+require "net/http"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+module Feedisco
+  def self.feed_content_types
+    [
+      'application/x.atom+xml',
+      'application/atom+xml',
+      'application/xml',
+      'text/xml',
+      'application/rss+xml',
+      'application/rdf+xml',
+    ]
+  end
+end
+
+require 'feedisco/discovery'
+
+Feedisco.extend Feedisco::Discovery
+
+$LOAD_PATH.shift

data/script/console

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+# This small script runs an IRB console ready for Feedisco fun!
+# Be sure to run within a `bundle exec` if your using Bundler!
+
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "feedisco.rb"))
+
+# prevent STDOUT & STDERR to be reopened (apps do this to be able to log under Passenger)
+def STDOUT.reopen(*args); end
+def STDERR.reopen(*args); end
+
+begin
+  require "pry"
+  Interpreter = Pry
+rescue LoadError
+  require "irb"
+  require "irb/completion"
+  Interpreter = IRB
+end
+
+# START
+Interpreter.start

data/spec/fixtures/alternate.html

@@ -0,0 +1,11 @@
+<html>
+
+<head>
+  <link rel="shortcut icon" href="http://example.com/shortcut.png">
+  <link rel="alternate" type="application/xml" href="http://example.com/feed.xml">
+</head>
+
+<body>
+</body>
+
+</html>

data/spec/fixtures/no_link.html

@@ -0,0 +1,12 @@
+<html>
+
+<head>
+  <link rel="shortcut icon" href="http://example.com/shortcut.png">
+  <link rel="alternate" type="application/nope" href="http://example.com/page.nope">
+</head>
+
+<body>
+  <a href="http://example.com/feed.nope">feed.nope</a>
+</body>
+
+</html>

data/spec/fixtures/one_link_in_body.html

@@ -0,0 +1,12 @@
+<html>
+
+<head>
+  <link rel="shortcut icon" href="http://example.com/shortcut.png">
+  <link rel="alternate" type="application/nope" href="http://example.com/page.nope">
+</head>
+
+<body>
+  <a href="http://example.com/feed.rss">feed.rss</a>
+</body>
+
+</html>

data/spec/fixtures/several_links.html

@@ -0,0 +1,15 @@
+<html>
+
+<head>
+  <link rel="shortcut icon" href="http://example.com/shortcut.png">
+  <link rel="alternate" type="application/xml" href="http://example.com/feed.xml">
+</head>
+
+<body>
+<a href="http://another.domain.com/feed.rss">another domain's feed.rss</a>
+<a href="http://example.com/feed.rss">feed.rss</a>
+<a href="http://another.domain.com/feed.rss">another domain's feed.rss</a>
+<a href="http://example.com/feed.rss">feed.rss</a>
+</body>
+
+</html>

data/spec/lib/checks_spec.rb

@@ -0,0 +1,36 @@
+require 'feedisco'
+
+describe "Feedisco::Checks" do
+  
+  describe 'looks_like_feed?' do
+
+    %w(feed.rdf feed.xml feed.rss feed?feed=atom feed?feed=rss feed/atom feed/feed feed/atom/ feed/feed/).each do |url|
+      it "should return true for '#{url}' " do
+        Feedisco.looks_like_feed?(url).should be_true
+      end
+    end
+
+    %w(feed.txt feed?feed=atomic feed=none example.com/atomic).each do |url|
+      it "should return false for '#{url}' " do
+        Feedisco.looks_like_feed?(url).should_not be_true
+      end
+    end
+  end
+
+  describe 'feed? (using real websites, may break if they change)' do
+
+    ['http://feeds.rchampourlier.com/rchampourlier',
+     'http://rss.cnn.com/rss/cnn_topstories.rss'].each do |url|
+      it "should return true for '#{url}'" do
+        Feedisco.feed?(url).should be_true
+      end
+    end
+
+    ['http://rchampourlier.com',
+     'http://www.cnn.com/services/rss/'].each do |url|
+      it "should return false for '#{url}'" do
+        Feedisco.feed?(url).should_not be_true
+      end
+    end
+  end
+end

data/spec/lib/discovery_spec.rb

@@ -0,0 +1,117 @@
+require 'feedisco'
+
+describe "Feedisco::Discovery" do
+  
+  describe "find" do
+  
+    it 'should raise an ArgumentError if specified url is nil' do
+      expect {
+        Feedisco.find(nil)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'should return an array with only the specified URL if it has a feed content type' do
+      file = stub(:class => stub(:to_s => 'Tempfile'), :content_type => 'application/xml')
+
+      Feedisco.should_receive(:open).and_yield(file)
+      Feedisco.find('example.com/feed.xml').should == ['http://example.com/feed.xml']
+    end
+
+    context 'from fixtures' do
+
+      it 'should return an empty array' do
+        file = File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'no_link.html'))
+        file.stub!(:class => stub(:to_s => 'Tempfile'), :content_type => 'text/html')
+
+        Feedisco.should_receive(:open).and_yield(file)
+        Feedisco.find('example.com').should == []
+      end
+
+      it 'should include the alternate link' do
+        file = File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'alternate.html'))
+        file.stub!(:class => stub(:to_s => 'Tempfile'), :content_type => 'text/html')
+
+        Feedisco.should_receive(:open).and_yield(file)
+        Feedisco.find('example.com').should include('http://example.com/feed.xml')
+      end
+
+      it 'should include a <a> link in the body' do
+        file = File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'one_link_in_body.html'))
+        file.stub!(:class => stub(:to_s => 'Tempfile'), :content_type => 'text/html')
+
+        Feedisco.should_receive(:open).and_yield(file)
+        Feedisco.find('example.com').should include("http://example.com/feed.rss")
+      end
+
+      it 'should include link to feeds on the URL\'s domain' do
+        file = File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'several_links.html'))
+        file.stub!(:class => stub(:to_s => 'Tempfile'), :content_type => 'text/html')
+
+        Feedisco.should_receive(:open).and_yield(file)
+        Feedisco.find('example.com').should include("http://example.com/feed.rss")
+      end
+
+      it 'should have the alternate link as the first of the returned feed' do
+        file = File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'several_links.html'))
+        file.stub!(:class => stub(:to_s => 'Tempfile'), :content_type => 'text/html')
+
+        Feedisco.should_receive(:open).and_yield(file)
+        Feedisco.find('example.com').first.should == "http://example.com/feed.xml"
+      end
+
+      it 'should include link to feeds on other domains' do
+        file = File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'several_links.html'))
+        file.stub!(:class => stub(:to_s => 'Tempfile'), :content_type => 'text/html')
+
+        Feedisco.should_receive(:open).and_yield(file)
+        Feedisco.find('example.com').should include "http://another.domain.com/feed.rss"
+      end
+
+      it 'should have links to feeds on other domains after links to feeds on the same domain' do
+        file = File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'several_links.html'))
+        file.stub!(:class => stub(:to_s => 'Tempfile'), :content_type => 'text/html')
+
+        Feedisco.should_receive(:open).and_yield(file)
+        feeds = Feedisco.find('example.com')
+        feeds.index('http://example.com/feed.rss').should < feeds.index('http://another.domain.com/feed.rss')
+      end
+
+      it 'should include each link only once' do
+        file = File.open(File.join(File.dirname(__FILE__), '..', 'fixtures', 'several_links.html'))
+        file.stub!(:class => stub(:to_s => 'Tempfile'), :content_type => 'text/html')
+
+        Feedisco.should_receive(:open).and_yield(file)
+        feeds = Feedisco.find('example.com')
+        feeds.select { |f| f == 'http://example.com/feed.rss' }.count.should == 1
+      end
+    end
+
+    context 'from real websites (this may change so some examples may break)' do
+
+      it "should return the URL for a feed URL" do
+        Feedisco.find('http://feeds.rchampourlier.com/rchampourlier').should == ['http://feeds.rchampourlier.com/rchampourlier']
+      end
+
+      it "should return an empty array for 'www.google.com'" do
+        Feedisco.find("www.google.com").should == []
+      end
+    
+      it "should return 'http://feeds.rchampourlier.com/rchampourlier' for 'rchampourlier.com'" do
+        Feedisco.find("www.rchampourlier.com").should == ['http://feeds.rchampourlier.com/rchampourlier']
+      end
+    
+      it "should raise an URI::InvalidURIError for an invalid URL" do
+        expect {
+          Feedisco.find("not url")
+        }.to raise_error(URI::InvalidURIError)
+      end
+    
+      it "should raise an ArgumentError if the specified url's scheme is not 'http(s)' or 'feed'" do
+        expect {
+          Feedisco.find('ftp://rchampourlier.com')
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+  
+end

data/spec/lib/utilities_spec.rb

@@ -0,0 +1,41 @@
+require 'feedisco'
+
+describe "Feedisco::Utilities" do
+  
+  describe 'harmonize_url' do
+
+    { 'example.com' => 'http://example.com',
+      'example.com/page' => 'http://example.com/page',
+      'feed://example.com' => 'http://example.com',
+      'http://example.com' => 'http://example.com',
+      'https://example.com' => 'https://example.com',
+      'ftp://example.com' => nil
+    }.each do |url, expected|
+
+      it "should return '#{expected || :nil}' for '#{url}'" do
+        Feedisco.harmonize_url(url).should == expected
+      end
+    end
+  end
+
+  describe 'complete_extracted_url' do
+
+    it 'should return the extracted url if it is absolute' do
+      Feedisco.complete_extracted_url('http://example.com/page', 'http://example.com/another').should == 'http://example.com/page'
+    end
+
+    it 'should add the scheme and host if the extracted url is relative from the root path' do
+      Feedisco.complete_extracted_url('/page', 'http://example.com').should == 'http://example.com/page'
+    end
+
+    it 'should add the extracted_url\'s path if it\'s relative from the page\'s page' do
+      Feedisco.complete_extracted_url('page', 'http://example.com/root').should == 'http://example.com/root/page'
+    end
+
+    it 'should raise ArgumentError if both extracted and page urls are relative' do
+      expect {
+        Feedisco.complete_extracted_url('/relative', '/relative/too')
+      }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH << "." unless $LOAD_PATH.include?(".")
+require 'logger'
+
+##
+# Bundler and its require
+#
+begin
+  require "rubygems"
+  require "bundler"
+
+  if Gem::Version.new(Bundler::VERSION) <= Gem::Version.new("0.9.5")
+    raise RuntimeError, "Your bundler version is too old." +
+     "Run `gem install bundler` to upgrade."
+  end
+
+  # Set up load paths for all bundled gems
+  Bundler.setup
+rescue Bundler::GemNotFound
+  raise RuntimeError, "Bundler couldn't find some gems." +
+    "Did you run \`bundle install\`?"
+end
+Bundler.require

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: feedisco
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Romain Champourlier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Feedisco is a small and lightweight library focused on RSS/Atom feed
+  discovery. It is intended to do little, but to do it well!
+email: romain@softr.li
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- feedisco.gemspec
+- lib/feedisco.rb
+- lib/feedisco/checks.rb
+- lib/feedisco/discovery.rb
+- lib/feedisco/utilities.rb
+- lib/feedisco/version.rb
+- script/console
+- spec/fixtures/alternate.html
+- spec/fixtures/no_link.html
+- spec/fixtures/one_link_in_body.html
+- spec/fixtures/several_links.html
+- spec/lib/checks_spec.rb
+- spec/lib/discovery_spec.rb
+- spec/lib/utilities_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/rchampourlier/feedisco
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -595904197689466947
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A simple feed discovery library
+test_files: []