akamai_bookmarklet 0.1.0

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/lib/casrack_the_authenticator/require_cas.rb

@@ -0,0 +1,36 @@
+module CasrackTheAuthenticator
+  
+  class RequireCAS
+    
+    # Create a new RequireCAS middleware, which requires
+    # users to log in via CAS for _all_ requests, and
+    # returns a 401 Unauthorized if they aren't signed in.
+    #
+    # @param app the underlying Rack app.
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      if signed_in?(env)
+        @app.call(env)
+      else
+        unauthorized
+      end
+    end
+    
+    private
+    
+    # @return [true, false] whether the user is signed in via CAS.
+    def signed_in?(env)
+      !Rack::Request.new(env).session[CasrackTheAuthenticator::USERNAME_PARAM].nil?
+    end
+    
+    # @return [Array<Integer, Hash, String>] a 401 Unauthorized Rack response.
+    def unauthorized
+      [401, {}, "CAS Authentication is required"]
+    end
+    
+  end
+  
+end

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/lib/casrack_the_authenticator/service_ticket_validator.rb

@@ -0,0 +1,55 @@
+require 'nokogiri'
+
+module CasrackTheAuthenticator
+  
+  class ServiceTicketValidator
+    
+    VALIDATION_REQUEST_HEADERS = { 'Accept' => '*/*' }
+    
+    # Build a validator from a +configuration+, a
+    # +return_to+ URL, and a +ticket+.
+    #
+    # @param [CasrackTheAuthenticator::Configuration] configuration the CAS configuration
+    # @param [String] return_to_url the URL of this CAS client service
+    # @param [String] ticket the service ticket to validate
+    def initialize(configuration, return_to_url, ticket)
+      @uri = URI.parse(configuration.service_validate_url(return_to_url, ticket))
+    end
+    
+    # Request validation of the ticket from the CAS server's
+    # serviceValidate (CAS 2.0) function.
+    #
+    # Swallows all XML parsing errors (and returns +nil+ in those cases).
+    #
+    # @return [String, nil] a username if the response is valid; +nil+ otherwise.
+    #
+    # @raise any connection errors encountered.
+    def user
+      parse_user(get_validation_response_body)
+    end
+    
+    private
+    
+    def get_validation_response_body
+      result = ''
+      Net::HTTP.new(@uri.host, @uri.port).start do |c|
+        response = c.get "#{@uri.path}?#{@uri.query}", VALIDATION_REQUEST_HEADERS
+        result = response.body
+      end
+      result
+    end
+    
+    def parse_user(body)
+      begin
+        doc = Nokogiri::XML(body)
+        node   = doc.xpath('/cas:serviceResponse/cas:authenticationSuccess/cas:user').first
+        node ||= doc.xpath('/serviceResponse/authenticationSuccess/user').first  # try w/o the namespace just in case
+        node.nil? ? nil : node.content
+      rescue Nokogiri::XML::XPath::SyntaxError
+        nil
+      end
+    end
+    
+  end
+  
+end

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/lib/casrack_the_authenticator/simple.rb

@@ -0,0 +1,82 @@
+require 'rack'
+require 'rack/request'
+
+module CasrackTheAuthenticator
+  
+  # The most basic CAS client use-case: redirects to CAS
+  # if a middleware or endpoint beneath this one returns
+  # a 401 response. On successful redirection back from 
+  # CAS, puts the username of the CAS user in the session
+  # under <tt>:cas_user</tt>.
+  class Simple
+    
+    # Create a new CAS middleware.
+    # 
+    # @param app the underlying Rack application
+    # @param [Hash] options - see
+    #               CasrackTheAuthenticator::Configuration
+    #               for more information
+    def initialize(app, options)
+      @app = app
+      @configuration = CasrackTheAuthenticator::Configuration.new(options)
+    end
+    
+    # Processes the CAS user if a "ticket" parameter is passed,
+    # then calls the underlying Rack application; if the result
+    # is a 401, redirects to CAS; otherwise, returns the response
+    # unchanged.
+    #
+    # @return [Array<Integer, Hash, #each>] a Rack response
+    def call(env)
+      request = Rack::Request.new(env)
+      process_return_from_cas(request)
+      redirect_on_401(request, @app.call(env))
+    end
+    
+    private
+    
+    # ticket processing
+    
+      def process_return_from_cas(request)
+        ticket = request.params['ticket']
+        if ticket
+          validator = ServiceTicketValidator.new(@configuration, service_url(request), ticket)
+          request.session[CasrackTheAuthenticator::USERNAME_PARAM] = validator.user
+        end
+      end
+    
+    # redirection
+    
+      def redirect_on_401(request, response)
+        if response[0] == 401
+          redirect_to_cas(request)
+        else
+          response
+        end
+      end
+    
+      def redirect_to_cas(request)
+        service_url = service_url(request)
+        [ 
+          302,
+          {
+            'Location' => @configuration.login_url(service_url),
+            'Content-Type' => 'text/plain'
+          },
+          ["You are being redirected to CAS for sign-in."]
+        ]
+      end
+    
+    # utils  
+    
+      def service_url(request)
+        strip_ticket_param request.url
+      end
+    
+      def strip_ticket_param(url)
+        url.sub(/[\?&]ticket=[^\?&]+/, '')
+      end
+    
+  end
+  
+end

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/lib/casrack_the_authenticator.rb

@@ -0,0 +1,11 @@
+module CasrackTheAuthenticator
+  
+  USERNAME_PARAM = :cas_user
+  
+  autoload :Simple, 'casrack_the_authenticator/simple'
+  autoload :Configuration, 'casrack_the_authenticator/configuration'
+  autoload :ServiceTicketValidator, 'casrack_the_authenticator/service_ticket_validator'
+  autoload :RequireCAS, 'casrack_the_authenticator/require_cas'
+  autoload :Fake, 'casrack_the_authenticator/fake'
+  
+end

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/test/configuration_test.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ConfigurationTest < Test::Unit::TestCase
+  
+  def new_config
+    CasrackTheAuthenticator::Configuration.new @valid_params
+  end
+  
+  context 'a Casrack configuration' do
+    
+    setup do
+      @valid_params = {
+        :cas_login_url => 'http://cas.example.org/login',
+        :cas_service_validate_url => 'http://cas.example.org/service-validate',
+        :cas_server => 'http://cas.example.org'
+      }
+    end
+    
+    should 'be invalid with neither a :cas_server nor a :cas_login_url' do
+      assert_raises(ArgumentError) do
+        @valid_params[:cas_server] = @valid_params[:cas_login_url] = nil
+        new_config
+      end
+    end
+    
+    should 'be invalid with neither a :cas_server nor a :cas_service_validate_url' do
+      assert_raises(ArgumentError) do
+        @valid_params[:cas_server] = @valid_params[:cas_service_validate_url] = nil
+        new_config
+      end
+    end
+    
+    should "be invalid with a :cas_login_url that isn't really a URL" do
+      assert_raises(ArgumentError) do
+        @valid_params[:cas_login_url] = 'not a URL'
+        new_config
+      end
+    end
+    
+    should "be invalid with a :cas_service_validate_url that isn't really a URL" do
+      assert_raises(ArgumentError) do
+        @valid_params[:cas_service_validate_url] = 'not a URL'
+        new_config
+      end
+    end
+    
+    should 'use the login URL if given' do
+      base = @valid_params[:cas_login_url]
+      service = 'http://example.org'
+      assert_equal base + '?service=http%3A%2F%2Fexample.org', new_config.login_url(service)
+    end
+    
+    should 'use the service-validate URL if given' do
+      base = @valid_params[:cas_service_validate_url]
+      service = 'http://example.org'
+      ticket = 'ST-00192'
+      svurl = URI.parse new_config.service_validate_url(service, ticket)
+      assert svurl.to_s =~ /^#{base}/
+      assert_equal service, Rack::Utils.parse_query(svurl.query)['service']
+      assert_equal ticket, Rack::Utils.parse_query(svurl.query)['ticket']
+    end
+    
+    should 'provide a default login URL if none is given' do
+      @valid_params[:cas_login_url] = nil
+      base = 'http://cas.example.org/login'
+      service = 'http://example.org'
+      assert_equal base + '?service=http%3A%2F%2Fexample.org', new_config.login_url(service)
+    end
+    
+    should 'provide a default service-validate URL if none is given' do
+      @valid_params[:cas_service_validate_url] = nil
+      base = 'http://cas.example.org/serviceValidate'
+      service = 'http://example.org'
+      ticket = 'ST-373737'
+      svurl = URI.parse new_config.service_validate_url(service, ticket)
+      assert svurl.to_s =~ /^#{base}/
+      assert_equal service, Rack::Utils.parse_query(svurl.query)['service']
+      assert_equal ticket, Rack::Utils.parse_query(svurl.query)['ticket']
+    end
+    
+  end
+
+end

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/test/fake_test.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class FakeTest < Test::Unit::TestCase
+  
+  def self.should_let_the_response_bubble_up_unaltered
+    should 'let the response bubble up unaltered' do
+      assert_equal @app_response, @response
+    end
+  end
+  
+  def self.should_set_the_cas_user_to(user)
+    should "set the CAS user to #{user || '<nil>'}" do
+      assert_received(@app, :call) do |expects|
+        expects.with() do |env|
+          assert_equal user, Rack::Request.new(env).session[:cas_user]
+          true
+        end
+      end
+    end
+  end
+  
+  def self.should_prompt_http_basic_authentication
+    should 'prompt HTTP basic authentication' do
+      assert_equal 401, @response[0]
+      assert_equal 'Basic realm="CasrackTheAuthenticator::Fake"', @response[1]['WWW-Authenticate']
+    end
+  end
+  
+  def auth_headers(user)
+    { 'HTTP_AUTHORIZATION' => 'Basic '+ ["#{user}:passw0rd"].pack("m*") }
+  end
+  
+  context 'the Fake authenticator' do
+    
+    setup do
+      @app = Object.new
+      @fake = CasrackTheAuthenticator::Fake.new @app, 'jlevitt'
+    end
+    
+    context 'when receiving a non-401 response' do
+      
+      setup do
+        @app_response = [ 320, {}, ["Weird redirection"] ]
+        @app.stubs(:call).returns @app_response
+        @response = @fake.call({})
+      end
+      
+      should_let_the_response_bubble_up_unaltered
+      
+    end
+    
+    context 'when receiving a 401 from below' do
+      
+      setup do
+        @app_response = [ 401, {}, 'Unauthorized!' ]
+        @app.stubs(:call).returns @app_response
+        @response = @fake.call({})
+      end
+      
+      should_prompt_http_basic_authentication
+      
+    end
+    
+    context 'when getting a valid HTTP Basic user in the request' do
+      
+      setup do
+        @app_response = [ 210, {}, ["Success-ish"] ]
+        @app.stubs(:call).returns @app_response
+        @response = @fake.call(auth_headers('jlevitt'))
+      end
+      
+      should_let_the_response_bubble_up_unaltered
+      
+      should_set_the_cas_user_to 'jlevitt'
+      
+    end
+    
+    context 'when getting an invalid HTTP Basic user in the request' do
+      
+      setup do
+        @app_response = [ 401, {}, [] ]
+        @app.stubs(:call).returns @app_response
+        @response = @fake.call(auth_headers('zdeschanel'))
+      end
+      
+      should_prompt_http_basic_authentication
+      
+      should_set_the_cas_user_to nil
+      
+    end
+    
+  end
+  
+end

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/test/service_ticket_validator_test.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'net/http'
+
+class ServiceTicketValidatorTest < Test::Unit::TestCase
+  
+  context 'a service-ticket validator' do
+    
+    setup do
+      config = Object.new
+      config.stubs(:service_validate_url).returns('http://cas.example.org/cas/serviceValidate?service=foo&ticket=bar')
+      @validator = CasrackTheAuthenticator::ServiceTicketValidator.new(config, nil, nil)
+    end
+    
+    context 'validating a ticket' do
+      
+      setup do
+        @server = Object.new
+        @connection = Object.new
+        @response = Object.new
+        @body = Object.new
+        Net::HTTP.stubs(:new).returns(@server)
+        @server.stubs(:start).yields(@connection)
+        @connection.stubs(:get).returns(@response)
+        @response.stubs(:body).returns(@body)
+      end
+      
+      should 'return the body from the service-validate URL' do
+        assert_equal @body, @validator.send(:get_validation_response_body)
+        assert_received(Net::HTTP, :new) do |expects|
+          expects.with('cas.example.org', 80)
+        end
+        assert_received(@server, :start)
+        assert_received(@connection, :get) do |expects|
+          expects.with('/cas/serviceValidate?service=foo&ticket=bar', { 'Accept' => '*/*' })
+        end
+        assert_received(@response, :body)
+      end
+      
+      context "but a connection error gets in the way" do
+        
+        setup do
+          @server.stubs(:start).raises(SocketError)
+        end
+      
+        should 'let the error percolate' do
+          assert_raises(SocketError) do
+            @validator.send(:get_validation_response_body)
+          end
+        end
+        
+      end
+      
+    end
+    
+    context 'parsing a successful response' do
+      
+      setup do
+        @body = <<-EOX
+<cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'>
+  <cas:authenticationSuccess>
+    <cas:user>beatrice</cas:user>
+  </cas:authenticationSuccess>
+</cas:serviceResponse>
+EOX
+      end
+      
+      should 'get the user' do
+        assert_equal 'beatrice', @validator.send(:parse_user, @body)
+      end
+    
+    end
+    
+    context 'parsing an unsuccessful response' do
+      setup do
+        @body = ''
+      end
+      
+      should 'return nil' do
+        assert_equal nil, @validator.send(:parse_user, @body)
+      end
+    end
+    
+  end
+  
+end

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/test/simple_test.rb

@@ -0,0 +1,131 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class SimpleTest < Test::Unit::TestCase
+  
+  context 'creating a Simple authenticator' do
+    should 'require a :cas_server' do
+      assert_raises(ArgumentError) do
+        CasrackTheAuthenticator::Simple.new(:anything, {})
+      end
+    end
+  end
+  
+  def self.should_pass_the_request_on_down
+    should "pass the request to the underyling app" do
+      assert_received(@app, :call)
+    end
+  end
+  
+  def self.should_set_the_cas_user_in_the_session_to(username)
+    should "set the CAS user in the session to #{username || '<nil>'}" do
+      assert_equal username, @session[:cas_user]
+    end
+  end
+  
+  def get(url)
+    env = Rack::MockRequest.env_for(url)
+    if @session
+      env['rack.session'] = @session
+    else
+      @session = Rack::Request.new(env).session
+    end
+    Rack::MockRequest.stubs(:env_for).returns(env)
+    @response = @request.get url
+  end
+  
+  def param_from_url(param, url)
+    uri = URI.parse(url)
+    Rack::Utils.parse_nested_query(uri.query)[param]
+  end
+  
+  def return_to_url(response)
+    param_from_url 'service', response.headers['Location']
+  end
+  
+  context 'a Simple authenticator' do
+    
+    setup do
+      @app = Object.new
+      @authenticator = CasrackTheAuthenticator::Simple.new(@app, {:cas_server => 'http://cas.test/'})
+      @request = Rack::MockRequest.new(@authenticator)
+    end
+    
+    context 'when receiving a 200 from below' do
+      
+      setup do
+        @response_from_below = [ 200, {}, 'Success!' ]
+        @app.stubs(:call).returns(@response_from_below)
+        get '/'
+      end
+      
+      should_pass_the_request_on_down
+
+      should 'do nothing to the response' do
+        assert_equal @response_from_below[0], @response.status
+        assert_equal @response_from_below[2], @response.body
+      end
+      
+    end
+    
+    context 'when receiving a 401 from below' do
+      
+      setup do
+        response = [401, {}, 'Unauthorized!']
+        @app.stubs(:call).returns(response)
+        @url = "http://foo.bar/baz?yoo=hoo"
+        get @url
+      end
+      
+      should_pass_the_request_on_down
+      
+      should 'redirect to CAS' do
+        assert((300..399).include?(@response.status))
+        assert @response.headers['Location'] =~ /cas/i
+      end
+      
+      should 'set the content-type to text/plain' do
+        assert_equal 'text/plain', @response.headers['Content-Type']
+      end
+      
+      should 'use the requested URL for the return-to' do
+        assert_equal @url, return_to_url(@response)
+      end
+      
+      context "and the request URL includes a 'ticket' param" do
+        
+        setup do
+          @url = "http://foo.bar/baz?ticket=12345"
+          get @url
+        end
+        
+        should 'strip the ticket from the return-to URL' do
+          return_to = return_to_url(@response)
+          assert_equal nil, param_from_url('ticket', return_to)
+        end
+        
+      end
+      
+    end
+    
+    context 'when receiving a valid result from CAS' do
+      
+      setup do
+        validator = Object.new
+        validator.stubs(:user).returns 'timmy'
+        CasrackTheAuthenticator::ServiceTicketValidator.stubs(:new).returns(validator)
+        @response_from_below = [ 200, {}, 'Success!' ]
+        @app.stubs(:call).returns(@response_from_below)
+        get '/?ticket=ST-77889'
+      end
+      
+      should_set_the_cas_user_in_the_session_to 'timmy'
+      
+      should 'build a service-ticket validator' do
+        assert_received(CasrackTheAuthenticator::ServiceTicketValidator, :new)
+      end
+      
+    end
+    
+  end
+  
+end

data/vendor/gems/ruby/1.8/gems/casrack_the_authenticator-1.6.0/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'test/unit/testcase'
+require 'rubygems'
+require 'shoulda'
+gem 'jferris-mocha'
+require 'mocha'
+require 'redgreen'
+
+I_KNOW_I_AM_USING_AN_OLD_AND_BUGGY_VERSION_OF_LIBXML2 = 1
+
+lib_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$: << lib_path unless $:.include?(lib_path)
+
+require 'casrack_the_authenticator'
+require 'rack'
+require 'rack/mock'

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/.autotest

@@ -0,0 +1,27 @@
+# -*- ruby -*-
+
+begin
+  require 'autotest/fsevent'
+rescue LoadError
+end
+
+Autotest.add_hook :run_command do |at|
+  at.unit_diff = 'cat'
+  if ENV['ONENINE']
+    system "rake1.9 compile"
+  else
+    system "rake compile"
+  end
+end
+
+Autotest.add_hook :ran_command do |at|
+  File.open('/tmp/autotest.txt', 'wb') { |f|
+    f.write(at.results.join)
+  }
+end
+
+class Autotest
+  def ruby
+    'ruby1.9'
+  end
+end if ENV['ONENINE']

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/.require_paths

@@ -0,0 +1,3 @@
+lib
+ext
+bin