fletcherm-culerity 0.2.5

data/lib/culerity/jruby_runner.rb

@@ -0,0 +1,13 @@
+module Culerity
+  class JRubyRunner
+    def self.cmd
+      jruby_complete = "#{File.dirname(__FILE__)}/../../vendor/jruby/jruby-complete-1.4.0.jar"
+      celerity = "#{File.dirname(__FILE__)}/../../vendor/gems/celerity-0.7.6/lib"
+      "java -Xmx500m -Xss1024k -jar #{jruby_complete} -I#{celerity}"
+    end
+
+    def self.run(command_to_run)
+      `#{cmd} #{command_to_run}`
+    end
+  end
+end

data/lib/culerity/remote_browser_proxy.rb

@@ -0,0 +1,58 @@
+module Culerity
+
+  class RemoteBrowserProxy < RemoteObjectProxy
+    def initialize(io, browser_options = {})
+      @io = io
+      @remote_object_id = "celerity".inspect
+      @remote_object_id = new_browser(browser_options).inspect
+    end
+    
+    # 
+    # Calls the block until it returns true or +time_to_wait+ is reached.
+    # +time_to_wait+ is 30 seconds by default
+    # 
+    # Returns true upon success
+    # Raises Timeout::Error when +time_to_wait+ is reached.
+    # 
+    def wait_until time_to_wait=30, &block
+      Timeout.timeout(time_to_wait) do
+        until block.call
+          sleep 0.1
+        end
+      end
+      true
+    end
+    
+    # 
+    # Calls the block until it doesn't return true or +time_to_wait+ is reached.
+    # +time_to_wait+ is 30 seconds by default
+    # 
+    # Returns true upon success
+    # Raises Timeout::Error when +time_to_wait+ is reached.
+    # 
+    def wait_while time_to_wait=30, &block
+      Timeout.timeout(time_to_wait) do
+        while block.call
+          sleep 0.1
+        end
+      end
+      true
+    end
+    
+    
+    #
+    # Specify whether to accept or reject all confirm js dialogs
+    # for the code in the block that's run.
+    # 
+    def confirm(bool, &block)
+      blk = "lambda { #{bool} }"
+      
+      self.send_remote(:add_listener, :confirm) { blk }
+      block.call
+      self.send_remote(:remove_listener, :confirm) { blk }
+    end
+    
+  end
+  
+  
+end

data/lib/culerity/remote_object_proxy.rb

@@ -0,0 +1,76 @@
+module Culerity
+
+  class CulerityException < StandardError
+    def initialize(message, backtrace)
+      super message
+      #self.backtrace = backtrace
+    end
+  end
+
+  class RemoteObjectProxy
+    def initialize(remote_object_id, io)
+      @remote_object_id = remote_object_id
+      @io = io
+    end
+
+    #
+    # Commonly used to get the HTML id attribute
+    # Use `object_id` to get the local objects' id.
+    #
+    def id
+      send_remote(:id)
+    end
+
+    def method_missing(name, *args)
+      send_remote(name, *args)
+    end
+
+    #
+    # Calls the passed method on the remote object with any arguments specified.
+    # Behaves the same as <code>Object#send</code>.
+    #
+    # If you pass it a block then it will append the block as a "lambda { … }".
+    # If your block returns a lambda string ("lambda { … }") then it will be passed
+    # straight through, otherwise it will be wrapped in a lambda string before sending.
+    #
+    def send_remote(name, *args, &blk)
+      input = [remote_object_id, %Q{"#{name}"}, *args.map{|a| a.inspect}]
+      input << block_to_string(&blk) if block_given?
+      @io << "[#{input.join(", ")}]\n"
+      process_result @io.gets.to_s.strip
+    end
+
+    def exit
+      @io << '["_exit_"]'
+    end
+
+    private
+
+    def process_result(result)
+      res = eval result
+      if res.first == :return
+        res[1]
+      elsif res.first == :exception
+        raise CulerityException.new("#{res[1]}: #{res[2]}", res[3])
+      end
+    end
+
+    #
+    # Takes a block and either returns the result (if it returns "lambda { … }")
+    # or builds the lambda string with the result of the block in it.
+    #
+    # Returns a string in the format "lambda { … }"
+    #
+    def block_to_string &block
+      result = block.call.to_s
+      unless result.is_a?(String) && result[/^lambda \s* \{ .*? \}/x]
+        result = "lambda { #{result} }"
+      end
+      result
+    end
+
+    def remote_object_id
+      @remote_object_id
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'culerity'

data/rails_generators/culerity/culerity_generator.rb

@@ -0,0 +1,28 @@
+class CulerityGenerator < Rails::Generator::Base
+  
+  def manifest
+    record do |m|
+      m.directory 'features/step_definitions'
+      m.file 'features/step_definitions/culerity_steps.rb', 'features/step_definitions/culerity_steps.rb'
+      m.file 'features/support/env.rb', 'features/support/env.rb'
+      m.file 'config/environments/culerity_continuousintegration.rb', 'config/environments/culerity_continuousintegration.rb'
+      m.file 'config/environments/culerity_development.rb', 'config/environments/culerity_development.rb'
+
+      m.gsub_file 'config/database.yml', /cucumber:.*\n/, "cucumber: &CUCUMBER\n"
+
+      m.gsub_file 'config/database.yml', /\z/, "\nculerity_development:\n  <<: *CUCUMBER"
+      m.gsub_file 'config/database.yml', /\z/, "\nculerity_continuousintegration:\n  <<: *CUCUMBER"
+      
+      m.file "lib/tasks/culerity.rake", "lib/tasks/culerity.rake"
+      
+      m.file 'public/javascripts/culerity.js', 'public/javascripts/culerity.js'
+    end
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} culerity"
+  end
+
+end

data/rails_generators/culerity/templates/config/environments/culerity_continuousintegration.rb

@@ -0,0 +1,28 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The production environment is meant for finished, "live" apps.
+# Code is not reloaded between requests
+config.cache_classes = true
+
+# Full error reports are disabled and caching is turned on
+config.action_controller.consider_all_requests_local = false
+config.action_controller.perform_caching             = true
+config.action_view.cache_template_loading            = true
+
+# See everything in the log (default is :info)
+# config.log_level = :debug
+
+# Use a different logger for distributed setups
+# config.logger = SyslogLogger.new
+
+# Use a different cache store in production
+# config.cache_store = :mem_cache_store
+
+# Enable serving of images, stylesheets, and javascripts from an asset server
+# config.action_controller.asset_host = "http://assets.example.com"
+
+# Disable delivery errors, bad email addresses will be ignored
+# config.action_mailer.raise_delivery_errors = false
+
+# Enable threaded mode
+# config.threadsafe!

data/rails_generators/culerity/templates/config/environments/culerity_development.rb

@@ -0,0 +1,17 @@
+config.cache_classes = false
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+config.action_view.cache_template_loading            = false
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell Action Mailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test

data/rails_generators/culerity/templates/features/step_definitions/culerity_steps.rb

@@ -0,0 +1,109 @@
+require 'culerity'
+
+Before do
+  $rails_server ||= Culerity::run_rails(:environment => 'culerity_development', :port => 3001)
+  $server ||= Culerity::run_server
+  $browser = Culerity::RemoteBrowserProxy.new $server, {:browser => :firefox3,
+    :javascript_exceptions => true,
+    :resynchronize => true,
+    :status_code_exceptions => true
+  }
+  $browser.log_level = :warning
+  @host = 'http://localhost:3001'
+end
+
+at_exit do
+  $browser.exit if $browser
+  $server.close if $server
+  Process.kill(6, $rails_server.pid.to_i) if $rails_server
+end
+
+When /I follow "([^\"]*)"/ do |link|
+  _link = [[:text, /^#{Regexp.escape(link)}$/], [:id, link], [:title, link]].map{|args| $browser.link(*args)}.find{|__link| __link.exist?}
+  raise "link \"#{link}\" not found" unless _link
+  _link.click
+  assert_successful_response
+end
+
+When /I press "([^\"]*)"/ do |button|
+  $browser.button(:text, button).click
+  assert_successful_response
+end
+
+When /I fill in "([^\"]*)" with "([^\"]*)"/ do |field, value|
+  find_by_label_or_id(:text_field, field).set(value)
+end
+
+When /I fill in "([^\"]*)" for "([^\"]*)"/ do |value, field|
+  find_by_label_or_id(:text_field, field).set(value)
+end
+
+When /I check "([^\"]*)"/ do |field|
+  find_by_label_or_id(:check_box, field).set(true)
+end
+
+When /^I uncheck "([^\"]*)"$/ do |field|
+  find_by_label_or_id(:check_box, field).set(true)
+end
+
+When /I select "([^\"]*)" from "([^\"]*)"/ do |value, field|
+  find_by_label_or_id(:select_list, field).select value
+end
+
+When /I choose "([^\"]*)"/ do |field|
+  find_by_label_or_id(:radio, field).set(true)
+end
+
+When /I go to (.+)/ do |path|
+  $browser.goto @host + path_to(path)
+  assert_successful_response
+end
+
+When /^I wait for the AJAX call to finish$/ do
+  $browser.wait_while do
+    begin
+      count = $browser.execute_script("window.running_ajax_calls").to_i
+      count.to_i > 0
+    rescue => e
+      if e.message.include?('HtmlunitCorejsJavascript::Undefined')
+        raise "For 'I wait for the AJAX call to finish' to work please include culerity.js after including jQuery. If you don't use jQuery please rewrite culerity.js accordingly."
+      else
+        raise(e)
+      end
+    end
+  end
+end
+
+Then /I should see "([^\"]*)"/ do |text|
+  # if we simply check for the browser.html content we don't find content that has been added dynamically, e.g. after an ajax call
+  div = $browser.div(:text, /#{text}/)
+  div.should be_exist
+end
+
+Then /I should not see "([^\"]*)"/ do |text|
+  div = $browser.div(:text, /#{text}/)
+  div.should_not be_exist
+end
+
+def find_by_label_or_id(element, attribute)
+  matchers = [[attribute, :id], [attribute, :name]]
+  matchers << [$browser.label(:text, attribute).for, :id] if $browser.label(:text, attribute).exist?
+  field = matchers.map{|_field, matcher| $browser.send(element, matcher, _field)}.find(&:exist?) ||  raise("#{element} not found using  \"#{attribute}\"")
+end
+
+def assert_successful_response
+  status = $browser.page.web_response.status_code
+  if(status == 302 || status == 301)
+    location = $browser.page.web_response.get_response_header_value('Location')
+    puts "Being redirected to #{location}"
+    $browser.goto location
+    assert_successful_response
+  elsif status != 200
+    filename = "culerity-#{Time.now.to_i}.html"
+    File.open(RAILS_ROOT + "/tmp/#{filename}", "w") do |f|
+      f.write $browser.html
+    end
+    `open tmp/#{filename}`
+    raise "Browser returned Response Code #{$browser.page.web_response.status_code}"
+  end
+end

data/rails_generators/culerity/templates/features/support/env.rb

@@ -0,0 +1,9 @@
+ENV["RAILS_ENV"] ||= "culerity_development"
+require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+require 'cucumber/rails/world'
+
+Cucumber::Rails::World.use_transactional_fixtures = false
+ActionController::Base.allow_rescue = false
+
+require 'cucumber/formatter/unicode'
+require 'cucumber/rails/rspec'

data/rails_generators/culerity/templates/lib/tasks/culerity.rake

@@ -0,0 +1,38 @@
+namespace 'culerity' do
+  namespace 'rails' do
+    desc "Starts a rails server for cucumber/culerity tests"
+    task :start do
+      port = ENV['PORT'] || 3001
+      environment = ENV["RAILS_ENV"] || 'culerity_development'
+      pid_file = RAILS_ROOT + "/tmp/culerity_rails_server.pid"
+      if File.exists?(pid_file)
+        puts "culerity rails server already running; if not, delete tmp/culerity_rails_server.pid and try again"
+        exit 1
+      end
+      rails_server = IO.popen("script/server -e #{environment} -p #{port}", 'r+')
+      File.open(pid_file, "w") { |file| file << rails_server.pid }
+    end
+
+    desc "Stops the running rails server for cucumber/culerity tests"
+    task :stop do
+      pid_file = RAILS_ROOT + "/tmp/culerity_rails_server.pid"
+      if File.exists?(pid_file)
+        pid = File.read(pid_file).to_i
+        Process.kill(6, pid)
+        File.delete(pid_file)
+      else
+        puts "No culerity rails server running. Doing nothing."
+      end
+    end
+
+    desc "Restarts the rails server for cucumber/culerity tests"
+    task :restart => [:stop, :start]
+  end
+  
+  desc "Install required gems into jruby"
+  task :install do
+    jgem_cmd = `which jruby`.strip
+    raise "ERROR: You need to install jruby to use culerity and celerity." if jgem_cmd.blank?
+    sh "#{jgem_cmd} -S gem install celerity"
+  end
+end

data/rails_generators/culerity/templates/public/javascripts/culerity.js

@@ -0,0 +1,27 @@
+// this allows culerity to wait until all ajax requests have finished
+jQuery(function($) {
+	var original_ajax = $.ajax;
+	var count_down = function(callback) {
+		return function() {
+			try {
+				if(callback) {
+					callback.apply(this, arguments);
+				};
+			} catch(e) {
+				window.running_ajax_calls -= 1;
+				throw(e);
+			}
+			window.running_ajax_calls -= 1;
+		}
+	};
+	window.running_ajax_calls = 0;
+	
+	var ajax_with_count = function(options) {
+		window.running_ajax_calls += 1;
+		options.success = count_down(options.success);
+		options.error = count_down(options.error);
+		original_ajax(options);
+	};
+
+	$.ajax = ajax_with_count;
+});

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/culerity.rb'}"
+puts "Loading culerity gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)