integrity 0.1.9 → 0.1.9.1

data/vendor/webrat/lib/webrat/core/xml/rexml.rb

@@ -1,24 +0,0 @@
-module Webrat
-  
-  def self.rexml_document(stringlike)
-    stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
-
-    case stringlike
-    when REXML::Document
-      stringlike.root
-    when REXML::Node, Array
-      stringlike
-    else
-      begin
-        REXML::Document.new(stringlike.to_s).root
-      rescue REXML::ParseException => e
-        if e.message.include?("second root element")
-          REXML::Document.new("<fake-root-element>#{stringlike}</fake-root-element>").root
-        else
-          raise e
-        end
-      end
-    end
-  end
-  
-end

data/vendor/webrat/lib/webrat/core_extensions/blank.rb

@@ -1,58 +0,0 @@
-class Object #:nodoc:
-  # An object is blank if it's false, empty, or a whitespace string.
-  # For example, "", "   ", +nil+, [], and {} are blank.
-  #
-  # This simplifies
-  #
-  #   if !address.nil? && !address.empty?
-  #
-  # to
-  #
-  #   if !address.blank?
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-    
-  # An object is present if it's not blank.
-  def present?
-    !blank?
-  end
-end
-
-class NilClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-class FalseClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-class TrueClass #:nodoc:
-  def blank?
-    false
-  end
-end
-
-class Array #:nodoc:
-  alias_method :blank?, :empty?
-end
-
-class Hash #:nodoc:
-  alias_method :blank?, :empty?
-end
-
-class String #:nodoc:
-  def blank?
-    self !~ /\S/
-  end
-end
-
-class Numeric #:nodoc:
-  def blank?
-    false
-  end
-end

data/vendor/webrat/lib/webrat/core_extensions/deprecate.rb

@@ -1,8 +0,0 @@
-class Module #:nodoc:
-  def webrat_deprecate(old_method_name, new_method_name)
-    define_method old_method_name do |*args|
-      warn "#{old_method_name} is deprecated. Use #{new_method_name} instead."
-      __send__(new_method_name, *args)
-    end
-  end
-end

data/vendor/webrat/lib/webrat/core_extensions/detect_mapped.rb

@@ -1,12 +0,0 @@
-class Array #:nodoc:
-  
-  def detect_mapped
-    each do |element|
-      result = yield element
-      return result if result
-    end
-    
-    return nil
-  end
-  
-end

data/vendor/webrat/lib/webrat/core_extensions/meta_class.rb

@@ -1,6 +0,0 @@
-class ::Object #:nodoc:
-  def meta_class
-    class << self; self end
-  end
-end
-    

data/vendor/webrat/lib/webrat/core_extensions/nil_to_param.rb

@@ -1,5 +0,0 @@
-class NilClass #:nodoc:
-  def to_param
-    nil
-  end
-end

data/vendor/webrat/lib/webrat/mechanize.rb

@@ -1,74 +0,0 @@
-require "mechanize"
-
-module Webrat #:nodoc:
-  class MechanizeSession < Session #:nodoc:
-    
-    attr_accessor :response
-    alias :page :response
-    
-    def request_page(url, http_method, data) #:nodoc:
-      super(absolute_url(url), http_method, data)
-    end
-    
-    def get(url, data, headers_argument_not_used = nil)
-      @response = mechanize.get(url, data)
-    end
-
-    def post(url, data, headers_argument_not_used = nil)
-      post_data = data.inject({}) do |memo, param|
-        case param.last
-        when Hash
-          param.last.each {|attribute, value| memo["#{param.first}[#{attribute}]"] = value }
-        else
-          memo[param.first] = param.last
-        end
-        memo
-      end
-      @response = mechanize.post(url, post_data)
-    end
-    
-    def response_body
-      @response.content
-    end
-
-    def response_code
-      @response.code.to_i
-    end
-    
-    def mechanize
-      @mechanize = WWW::Mechanize.new
-    end
-
-    def_delegators :mechanize, :basic_auth
-    
-    def absolute_url(url) #:nodoc:
-      current_host, current_path = split_current_url
-      if url =~ Regexp.new('^https?://')
-        url
-      elsif url =~ Regexp.new('^/')
-        current_host + url
-      elsif url =~ Regexp.new('^\.')
-        current_host + absolute_path(current_path, url)
-      else
-        url
-      end
-    end
-    
-    private
-      def split_current_url
-        current_url =~ Regexp.new('^(https?://[^/]+)(/.*)?')
-        [Regexp.last_match(1), Regexp.last_match(2)]
-      end
-      
-      def absolute_path(current_path, url)
-        levels_up = url.split('/').find_all { |x| x == '..' }.size
-        ancestor = if current_path.nil?
-          ""
-        else
-          current_path.split("/")[0..(-1 - levels_up)].join("/")
-        end
-        descendent = url.split("/")[levels_up..-1]
-        "#{ancestor}/#{descendent}"
-      end
-  end
-end

data/vendor/webrat/lib/webrat/merb.rb

@@ -1,9 +0,0 @@
-require "webrat"
-
-# This is a temporary hack to support backwards compatibility
-# with Merb 1.0.8 until it's updated to use the new Webrat.configure
-# syntax
-
-Webrat.configure do |config|
-  config.mode = :merb
-end

data/vendor/webrat/lib/webrat/merb_session.rb

@@ -1,65 +0,0 @@
-require "webrat"
-
-require "cgi"
-gem "extlib"
-require "extlib"
-require "merb-core"
-
-# HashWithIndifferentAccess = Mash
-
-module Webrat
-  class MerbSession < Session #:nodoc:
-    include Merb::Test::MakeRequest
-    
-    attr_accessor :response
-    
-    def get(url, data, headers = nil)
-      do_request(url, data, headers, "GET")
-    end
-  
-    def post(url, data, headers = nil)
-      do_request(url, data, headers, "POST")
-    end
-  
-    def put(url, data, headers = nil)
-      do_request(url, data, headers, "PUT")
-    end
-  
-    def delete(url, data, headers = nil)
-      do_request(url, data, headers, "DELETE")
-    end
-    
-    def response_body
-      @response.body.to_s
-    end
-    
-    def response_code
-      @response.status
-    end
-    
-    def do_request(url, data, headers, method)
-      @response = request(url, 
-        :params => (data && data.any?) ? data : nil, 
-        :headers => headers,
-        :method => method)
-    end
-
-  end
-end
-
-module Merb #:nodoc:
-  module Test #:nodoc:
-    module RequestHelper #:nodoc:
-      def request(uri, env = {})
-        @_webrat_session ||= Webrat::MerbSession.new
-        @_webrat_session.response = @_webrat_session.request(uri, env)
-      end
-    end
-  end
-end
-
-class Merb::Test::RspecStory #:nodoc:
-  def browser
-    @browser ||= Webrat::MerbSession.new
-  end
-end

data/vendor/webrat/lib/webrat/rack.rb

@@ -1,24 +0,0 @@
-require 'webrat'
-
-class CGIMethods #:nodoc:
-  def self.parse_query_parameters(params)
-    hash = {}
-    params.split('&').each do |p|
-      pair = p.split('=')
-      hash[pair[0]] = pair[1]
-    end
-    hash
-  end
-end
-
-module Webrat
-  class RackSession < Session #:nodoc:
-    def response_body
-      @response.body
-    end
-
-    def response_code
-      @response.status
-    end
-  end
-end

data/vendor/webrat/lib/webrat/rails.rb

@@ -1,105 +0,0 @@
-require "webrat"
-
-require "action_controller"
-require "action_controller/integration"
-require "action_controller/record_identifier"
-
-module Webrat
-  class RailsSession < Session #:nodoc:
-    include ActionController::RecordIdentifier
-    
-    # The Rails version of within supports passing in a model and Webrat
-    # will apply a scope based on Rails' dom_id for that model.
-    #
-    # Example:
-    #   within User.last do
-    #     click_link "Delete"
-    #   end
-    def within(selector_or_object, &block)
-      if selector_or_object.is_a?(String)
-        super
-      else
-        super('#' + dom_id(selector_or_object), &block)
-      end
-    end
-    
-    def doc_root
-      File.expand_path(File.join(RAILS_ROOT, 'public'))
-    end
-
-    def saved_page_dir
-      File.expand_path(File.join(RAILS_ROOT, "tmp"))
-    end
-
-    def get(url, data, headers = nil)
-      do_request(:get, url, data, headers)
-    end
-
-    def post(url, data, headers = nil)
-      do_request(:post, url, data, headers)
-    end
-
-    def put(url, data, headers = nil)
-      do_request(:put, url, data, headers)
-    end
-
-    def delete(url, data, headers = nil)
-      do_request(:delete, url, data, headers)
-    end
-
-    def response_body
-      response.body
-    end
-
-    def response_code
-      response.code.to_i
-    end
-
-    def xml_content_type?
-      response.headers["Content-Type"].to_s =~ /xml/
-    end
-
-  protected
-
-    def integration_session
-      @context
-    end
-
-    def do_request(http_method, url, data, headers) #:nodoc:
-      update_protocol(url)
-      integration_session.send(http_method, normalize_url(url), data, headers)
-    end
-
-    # remove protocol, host and anchor
-    def normalize_url(href) #:nodoc:
-      uri = URI.parse(href)
-      normalized_url = []
-      normalized_url << "#{uri.scheme}://" if uri.scheme
-      normalized_url << uri.host if uri.host
-      normalized_url << ":#{uri.port}" if uri.port && ![80,443].include?(uri.port)
-      normalized_url << uri.path if uri.path
-      normalized_url << "?#{uri.query}" if uri.query
-      normalized_url.join
-    end
-
-    def update_protocol(href) #:nodoc:
-      if href =~ /^https:/
-        integration_session.https!(true)
-      elsif href =~ /^http:/
-        integration_session.https!(false)
-      end
-    end
-
-    def response #:nodoc:
-      integration_session.response
-    end
-
-  end
-end
-
-module ActionController #:nodoc:
-  IntegrationTest.class_eval do
-    include Webrat::Methods
-    include Webrat::Matchers
-  end
-end

data/vendor/webrat/lib/webrat/rspec-rails.rb

@@ -1,13 +0,0 @@
-# Supports using the matchers in controller, helper, and view specs if you're
-# using rspec-rails. Just add a require statement to spec/spec_helper.rb or env.rb:
-# 
-#   require 'webrat/rspec-rails'
-#
-require "webrat/core/matchers"
-
-Spec::Runner.configure do |config|
-  # rspec should support :type => [:controller, :helper, :view] - but until it does ...
-  config.include(Webrat::Matchers, :type => :controller)
-  config.include(Webrat::Matchers, :type => :helper)
-  config.include(Webrat::Matchers, :type => :view)
-end

data/vendor/webrat/lib/webrat/selenium.rb

@@ -1,154 +0,0 @@
-require "webrat"
-gem "selenium-client", ">=1.2.9"
-require "selenium/client"
-require "webrat/selenium/selenium_session"
-require "webrat/selenium/matchers"
-
-module Webrat
-
-  def self.with_selenium_server #:nodoc:
-    start_selenium_server
-    yield
-    stop_selenium_server
-  end
-
-  def self.start_selenium_server #:nodoc:
-    unless Webrat.configuration.selenium_server_address
-      remote_control = ::Selenium::RemoteControl::RemoteControl.new("0.0.0.0", Webrat.configuration.selenium_server_port, 5)
-      remote_control.jar_file = File.expand_path(__FILE__ + "../../../../vendor/selenium-server.jar")
-      remote_control.start :background => true
-    end
-    TCPSocket.wait_for_service :host => (Webrat.configuration.selenium_server_address || "0.0.0.0"), :port => Webrat.configuration.selenium_server_port
-  end
-
-  def self.stop_selenium_server #:nodoc:
-    ::Selenium::RemoteControl::RemoteControl.new("0.0.0.0", Webrat.configuration.selenium_server_port, 5).stop unless Webrat.configuration.selenium_server_address
-  end
-
-  def self.pid_file
-    if File.exists?('config.ru')
-      prepare_pid_file(Dir.pwd, 'rack.pid')
-    else
-      prepare_pid_file("#{RAILS_ROOT}/tmp/pids", "mongrel_selenium.pid")
-    end
-  end
-  # Start the appserver for the underlying framework to test
-  #
-  # Sinatra: requires a config.ru in the root of your sinatra app to use this
-  # Merb: Attempts to use bin/merb and falls back to the system merb
-  # Rails: Calls mongrel_rails to startup the appserver
-  def self.start_app_server
-    case Webrat.configuration.application_framework
-    when :sinatra
-      fork do
-        File.open('rack.pid', 'w') { |fp| fp.write Process.pid }
-        exec 'rackup', File.expand_path(Dir.pwd + '/config.ru'), '-p', Webrat.configuration.application_port.to_s
-      end
-    when :merb
-      cmd = 'merb'
-      if File.exist?('bin/merb')
-        cmd = 'bin/merb'
-      end
-      system("#{cmd} -d -p #{Webrat.configuration.application_port} -e #{Webrat.configuration.application_environment}")
-    else # rails
-      system("mongrel_rails start -d --chdir='#{RAILS_ROOT}' --port=#{Webrat.configuration.application_port} --environment=#{Webrat.configuration.application_environment} --pid #{pid_file} &")
-    end
-    TCPSocket.wait_for_service :host => Webrat.configuration.application_address, :port => Webrat.configuration.application_port.to_i
-  end
-
-  # Stop the appserver for the underlying framework under test
-  #
-  # Sinatra: Reads and kills the pid from the pid file created on startup
-  # Merb: Reads and kills the pid from the pid file created on startup
-  # Rails: Calls mongrel_rails stop to kill the appserver
-  def self.stop_app_server 
-    case Webrat.configuration.application_framework
-    when :sinatra
-      pid = File.read('rack.pid')
-      system("kill -9 #{pid}")
-      FileUtils.rm_f 'rack.pid'
-    when :merb
-      pid = File.read("log/merb.#{Webrat.configuration.application_port}.pid")
-      system("kill -9 #{pid}")
-      FileUtils.rm_f "log/merb.#{Webrat.configuration.application_port}.pid"
-    else # rails
-      system "mongrel_rails stop -c #{RAILS_ROOT} --pid #{pid_file}"
-    end
-  end
-
-  def self.prepare_pid_file(file_path, pid_file_name)
-    FileUtils.mkdir_p File.expand_path(file_path)
-    File.expand_path("#{file_path}/#{pid_file_name}")
-  end
-
-  # To use Webrat's Selenium support, you'll need the selenium-client gem installed.
-  # Activate it with (for example, in your <tt>env.rb</tt>):
-  #
-  #   require "webrat"
-  #
-  #   Webrat.configure do |config|
-  #     config.mode = :selenium
-  #   end
-  #
-  # == Dropping down to the selenium-client API
-  #
-  # If you ever need to do something with Selenium not provided in the Webrat API,
-  # you can always drop down to the selenium-client API using the <tt>selenium</tt> method.
-  # For example:
-  #
-  #   When "I drag the photo to the left" do
-  #     selenium.dragdrop("id=photo_123", "+350, 0")
-  #   end
-  #
-  # == Choosing the underlying framework to test
-  #
-  # Webrat assumes you're using rails by default but it can also work with sinatra
-  # and merb.  To take advantage of this you can use the configuration block to
-  # set the application_framework variable.
-  #   require "webrat"
-  #
-  #   Webrat.configure do |config|
-  #     config.mode = :selenium
-  #     config.application_port = 4567
-  #     config.application_framework = :sinatra  # could also be :merb
-  #   end
-  #
-  # == Auto-starting of the appserver and java server
-  #
-  # Webrat will automatically start the Selenium Java server process and an instance
-  # of Mongrel when a test is run. The Mongrel will run in the "selenium" environment
-  # instead of "test", so ensure you've got that defined, and will run on port
-  # Webrat.configuration.application_port.
-  #
-  # == Waiting
-  #
-  # In order to make writing Selenium tests as easy as possible, Webrat will automatically
-  # wait for the correct elements to exist on the page when trying to manipulate them
-  # with methods like <tt>fill_in</tt>, etc. In general, this means you should be able to write
-  # your Webrat::Selenium tests ignoring the concurrency issues that can plague in-browser
-  # testing, so long as you're using the Webrat API.
-  module Selenium
-    module Methods
-      def response
-        webrat_session.response
-      end
-
-      def wait_for(*args, &block)
-        webrat_session.wait_for(*args, &block)
-      end
-
-      def save_and_open_screengrab
-        webrat_session.save_and_open_screengrab
-      end
-    end
-  end
-end
-if defined?(ActionController::IntegrationTest)
-  module ActionController #:nodoc:
-    IntegrationTest.class_eval do
-      include Webrat::Methods
-      include Webrat::Selenium::Methods
-      include Webrat::Selenium::Matchers
-    end
-  end
-end