kauperts_link_checker 0.4.0

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    kauperts_link_checker (0.4.0)
+      i18n
+      simpleidn
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (2.3.11)
+    i18n (0.6.0)
+    mocha (0.9.12)
+    redgreen (1.2.2)
+    simpleidn (0.0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler
+  kauperts_link_checker!
+  mocha
+  redgreen

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2011, kaupert media gmbh
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the original author / copyright holder nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.rdoc

@@ -0,0 +1,40 @@
+== Kauperts::LinkChecker
+
+<b>Kauperts::LinkChecker</b> is a simple library to check for the well-being of URLs. It supports HTTPS and IDN URIs. 
+
+=== Installation
+The gem is not published yet and can be installed from github:
+ git clone git://github.com/kaupertmedia/kauperts_link_checker.git
+ cd kauperts_link_checker
+ gem build kauperts_link_checker.gemspec
+ gem install kauperts_link_checker-<gemversion>.gem
+
+Much easier using bundler:
+ # Gemfile
+ gem 'kauperts_link_checker', :git => "git://github.com/kaupermedia/kauperts_link_checker"
+
+=== Usage
+It will check any object that responds to +url+:
+  status = Kauperts::LinkChecker.check!(object_responding_to_url)
+  unless status.ok?
+    puts status 
+  end
+
+You can ignore 301 permanent redirect that only add a trailing slash like this:
+  status = Kauperts::LinkChecker.check!(object_responding_to_url, :ignore_trailing_slash_redirects => true)
+  unless status.ok?
+    # A redirect from http://example.com/foo to http://example.com/foo/ will be considered ok
+  end
+
+=== I18n
+The following keys are used to translate error messages using the I18n gem:
+* <tt>kauperts.link_checker.errors.timeout</tt>: message when rescueing from Timeout::Error
+* <tt>kauperts.link_checker.errors.generic_network</tt>: message when (currently) rescueing from all other exceptions
+
+=== Credits
+Kauperts::LinkChecker is extracted from a maintenance task made for
+{berlin.kauperts.de}[http://berlin.kauperts.de] by {kaupert media gmbh}[http://kaupertmedia.de].
+
+=== License
+Kauperts::LinkChecker is released under a 3-clause BSD-licence. See the LICENSE file for details.
+

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc "Default: run unit tests."
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Kauperts::LinkChecker'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/kauperts_link_checker.gemspec

@@ -0,0 +1,25 @@
+$:.push File.expand_path("../lib/", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = "kauperts_link_checker"
+  s.version       = "0.4.0"
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["Wolfgang Vogl", "Carsten Zimmermann"]
+  s.email         = ["carp@hacksocke.de"]
+  s.homepage      = ""
+  s.summary       = "A simple library to check for the well-being of an URL"
+  s.description   = "A simple library to check for the well-being of an URL"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency "i18n"
+  s.add_dependency "simpleidn"
+
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'redgreen'
+  s.add_development_dependency 'activesupport'
+end
+

data/lib/kauperts_link_checker.rb

@@ -0,0 +1,92 @@
+require "net/https"
+require "simpleidn"
+module Kauperts
+
+  # Checks the status of an object which responds to +url+. The returned
+  # status can be accessed via +status+. It contains either a string
+  # representation of a numeric http status code or an error message.
+  #
+  # Supports HTTPS and IDN-domains.
+  #
+  #
+  # The following keys are used to translate error messages using the I18n gem:
+  # * <tt>kauperts.link_checker.errors.timeout</tt>: rescues from Timeout::Error
+  # * <tt>kauperts.link_checker.errors.generic_network</tt>: (currently) rescues from all other exceptions
+  # * <tt>kauperts.link_checker.status.redirect_permanently</tt>: translation for 301 permanent redirects
+  class LinkChecker
+
+    attr_reader :configuration, :object, :status
+
+		class Configuration < Struct.new(:ignore_trailing_slash_redirects)
+		end
+
+    # === Parameters
+    # * +object+: an arbitrary object which responds to +url+.
+		# * +options+: optional configuration parameters, see below.
+		#
+		# === Available Options
+		# * +ignore_trailing_slash_redirects+: ignores redirects to the same URI but only with an added trailing slash (default: false)
+    def initialize(object, options = {})
+      object.respond_to?(:url) ? @object = object : raise(ArgumentError.new("object doesn't respond to url"))
+
+			# Assign config variables
+			@configuration = Configuration.new
+			options = { :ignore_trailing_slash_redirects => false }.merge(options).each do |key, val|
+				@configuration.send(:"#{key}=", val)
+			end
+
+    end
+
+    # Checks the associated url object. Sets and returns +status+
+    def check!
+      begin
+        uri = parsed_uri(@object.url)
+        if uri.scheme == 'https'
+          http = Net::HTTP.new(uri.host , 443)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          response = http.start{ http.get2(uri.to_s) }
+        else
+          response = Net::HTTP.get_response(uri)
+        end
+        status = if response.code == '301'
+                   @redirect_with_trailing_slash_only = "#{uri}/" == response['location']
+                   "#{I18n.t :"kauperts.link_checker.status.redirect_permanently", :default => "Moved permanently"} (#{response['location']})"
+                 else
+                   response.code
+                 end
+      rescue Timeout::Error => e
+        status = "#{I18n.t :"kauperts.link_checker.errors.timeout", :default => "Timeout"} (#{e.message})"
+      rescue Exception => e
+        status = "#{I18n.t :"kauperts.link_checker.errors.generic_network", :default => "Generic network error"} (#{e.message})"
+      end
+      @status = status
+    end
+
+    # Returns if a check has been run and the return code was '200 OK'
+    # or if a 301 permanent redirect only added a trailing slash
+    # while +ignore_trailing_slash_redirects+ has been set to true
+    def ok?
+      @status == '200' or (@redirect_with_trailing_slash_only == true and self.configuration.ignore_trailing_slash_redirects)
+    end
+
+    # Immediately checks +object+ and returns the LinkChecker instance
+    def self.check!(object)
+      checker = new(object)
+      checker.check!
+      checker
+    end
+
+    protected
+
+    # Transforms a possible IDN within +url+ into ASCII and returns
+    # a parsed URI instance.
+    def parsed_uri(url)
+      url_without_protocol = /^http[s]?:\/\/(.+)/.match(url)[1]
+      domain = url_without_protocol.split('/', 2)[0]
+      idn_domain = SimpleIDN.to_ascii(domain)
+      URI.parse(url.gsub(domain, idn_domain))
+    end
+
+  end
+end

data/test/link_checker_test.rb

@@ -0,0 +1,204 @@
+require 'test_helper'
+
+class LinkCheckerTest < ActiveSupport::TestCase
+
+  test "should accept objects responding to url" do
+    assert_nothing_raised do
+      assert checker.new(url_object)
+    end
+    assert_raises ArgumentError do
+      checker.new(Object.new)
+    end
+  end
+
+	test "should instantiate with optional configuration hash" do
+		assert defined?(Kauperts::LinkChecker::Configuration)
+
+		obj = checker.new(url_object)
+		assert_respond_to obj, :configuration
+
+		assert_respond_to obj.configuration, :ignore_trailing_slash_redirects
+		assert !obj.configuration.ignore_trailing_slash_redirects
+
+		obj = checker.new(url_object, :ignore_trailing_slash_redirects => true)
+
+		assert_respond_to obj.configuration, :ignore_trailing_slash_redirects
+		assert_equal true, obj.configuration.ignore_trailing_slash_redirects
+	end
+
+  test "should expose object" do
+    obj = checker.new(url_object)
+    assert_respond_to obj, :object
+  end
+
+  test "should have check! method" do
+    obj = checker.new(url_object)
+    assert_respond_to obj, :check!
+  end
+
+  test "should return status array with 200" do
+    stub_net_http!
+    url = url_object
+    obj = checker.new(url)
+    a = obj.check!
+    assert_equal "200", obj.check!
+  end
+
+	test "should ignore permanent redirects with trailing slash only if told so" do
+		url = url_object("http://www.example.com/foo")
+		location = url.url + "/"
+		stub_net_http_redirect!("301", location)
+
+		obj = checker.new(url)
+		obj.check!
+		assert_equal false, obj.ok?
+
+		obj = checker.new(url, :ignore_trailing_slash_redirects => true)
+		obj.check!
+		assert_equal true, obj.ok?
+	end
+
+  test "should return status array with 404" do
+    stub_net_http!("404")
+    url = url_object
+    obj = checker.new(url)
+    assert_equal "404", obj.check!
+  end
+
+  test "should handle time out exceptions" do
+    stub_net_http_error!(Timeout::Error, "Takes way too long")
+    url = url_object
+    obj = checker.new(url)
+    assert_nothing_raised do
+      status = obj.check!
+      assert_kind_of String, status
+      assert_match /Timeout (.+)/, status
+    end
+  end
+
+  test "should handle generic network problem" do
+    class GenericNetworkException < Exception; end
+    stub_net_http_error!(GenericNetworkException, "Somehow broken")
+    url = url_object
+    obj = checker.new(url)
+    assert_nothing_raised do
+      status = obj.check!
+      assert_kind_of String, status
+      assert_match /Generic network error (.+)/, status
+    end
+  end
+
+  test "should handle domain with umlauts" do
+    SimpleIDN.expects(:to_ascii).returns('www.xn--trotzkpfchen-9ib.de').at_least(1)
+    stub_net_http!
+    url = url_object('http://www.trotzköpfchen.de')
+    obj = checker.new(url)
+    assert_equal "200", obj.check!
+  end
+
+  test "should handle ssl protocol" do
+    stub_net_https!
+    url = url_object(nil, "https")
+    obj = checker.new(url)
+    assert_equal "200", obj.check!
+  end
+
+  test "should have status" do
+    stub_net_http!
+    url = url_object
+    obj = checker.new(url)
+    assert_respond_to obj, :status
+    assert_nil obj.status
+    obj.check!
+    assert_not_nil obj.status
+  end
+
+  test "should have ok? method" do
+    stub_net_http!
+    url = url_object
+    obj = checker.new(url)
+    assert_respond_to obj, :ok?
+    assert !obj.ok?
+    obj.check!
+    assert obj.ok?
+  end
+
+  test "should check directly when called from class" do
+    stub_net_http!
+    url = url_object
+    assert_respond_to checker, :check!
+    assert_raises ArgumentError do
+      checker.check!
+    end
+    assert_kind_of checker, checker.check!(url)
+  end
+
+  test "should support I18n message for timeout error" do
+    I18n.expects(:t).with(:"kauperts.link_checker.errors.timeout", :default => "Timeout").returns('Zeitüberschreitung')
+    stub_net_http_error!(Timeout::Error, "Dauert zu lange")
+    url = url_object
+    assert_match /Zeitüberschreitung (.+)/, checker.check!(url).status
+  end
+
+  test "should support I18n message for generic network error" do
+    I18n.expects(:t).with(:"kauperts.link_checker.errors.generic_network", :default => "Generic network error").returns('Netzwerkfehler')
+    class GenericNetworkException < Exception; end
+    stub_net_http_error!(GenericNetworkException, "Irgendwie kaputt")
+    url = url_object
+    assert_match /Netzwerkfehler (.+)/, checker.check!(url).status
+  end
+
+  test "should return redirection url" do
+    stub_net_http_redirect!
+    url = url_object
+    assert_match /auenland.de/, checker.check!(url).status
+  end
+
+  test "should support I18n message for 301 permanent redirects" do
+    I18n.expects(:t).with(:"kauperts.link_checker.status.redirect_permanently", :default => "Moved permanently").returns('Umgezogen')
+    location = "http://auenland.de"
+    stub_net_http_redirect!(301, location)
+    url = url_object
+    assert_match /Umgezogen \(#{location}\)/, checker.check!(url).status
+  end
+
+
+  protected
+
+  def checker
+    Kauperts::LinkChecker
+  end
+
+  def stub_net_http!(return_code = "200")
+    return_code = return_code.to_s
+    mock_response = mock('response')
+    mock_response.stubs(:code).returns(return_code)
+    Net::HTTP.stubs(:get_response).returns(mock_response)
+  end
+
+	def stub_net_https!(return_code = "200")
+    return_code = return_code.to_s
+    mock_response = mock('sslresponse')
+    mock_response.stubs(:code).returns(return_code)
+    Net::HTTP.any_instance.stubs(:start).returns(mock_response)
+	end
+
+  def stub_net_http_error!(exception, message)
+    Net::HTTP.stubs(:get_response).raises(exception, message)
+  end
+
+  def stub_net_http_redirect!(return_code = '301', location ="http://auenland.de")
+    return_code = return_code.to_s
+    mock_response = {'location' => location}
+    mock_response.stubs(:code).returns(return_code)
+    Net::HTTP.stubs(:get_response).returns(mock_response)
+  end
+
+  def url_object(url = nil, protocol = 'http')
+    obj = mock('url_object')
+    url ||= "#{protocol}://www.google.com"
+    obj.stubs(:url).returns(url)
+    obj
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'test/unit'
+require 'active_support/test_case'
+Bundler.require(:default, :development)
+
+require 'kauperts_link_checker'

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: kauperts_link_checker
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
+platform: ruby
+authors: 
+- Wolfgang Vogl
+- Carsten Zimmermann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-05 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: simpleidn
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: redgreen
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: A simple library to check for the well-being of an URL
+email: 
+- carp@hacksocke.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- kauperts_link_checker.gemspec
+- lib/kauperts_link_checker.rb
+- test/link_checker_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: A simple library to check for the well-being of an URL
+test_files: 
+- test/link_checker_test.rb
+- test/test_helper.rb