culerity 0.2.3

data/features/step_definitions/culerity_setup_steps.rb

@@ -0,0 +1,7 @@
+When /^I setup load path to local code$/ do
+  project_lib_path = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  in_project_folder do
+    force_local_lib_override(:target => 'features/step_definitions/common_celerity_steps.rb')
+  end
+end
+

data/features/step_definitions/jruby_steps.rb

@@ -0,0 +1,11 @@
+Given /^I have jruby installed$/ do
+  @jruby_cmd = `which jruby`.strip
+  raise "Need to setup @jruby_cmd to test jruby environment" if @jruby_cmd.blank?
+end
+
+Then /^the gem "([^\"]*)" is installed into jruby environment$/ do |gem_name|
+  raise "Need to setup @jruby_cmd to test jruby environment" if @jruby_cmd.blank?
+  gem_list = `#{@jruby_cmd} -S gem list #{gem_name}`
+  gem_list.should =~ /#{gem_name}/
+end
+

data/features/step_definitions/rails_setup_steps.rb

@@ -0,0 +1,26 @@
+Given /^a Rails app$/ do
+  FileUtils.chdir(@tmp_root) do
+    `rails my_project`
+  end
+  @active_project_folder = File.expand_path(File.join(@tmp_root, "my_project"))
+end
+
+Given /^I copy the project generators into "([^\"]*)"$/ do |target_folder|
+  in_project_folder do
+    FileUtils.mkdir_p(target_folder)
+  end
+  `cp -rf #{File.dirname(__FILE__) + "/../../rails_generators/*"} #{File.join(@active_project_folder, target_folder)}`
+end
+
+When /^I add a feature file to test Rails index.html default file$/ do
+  sample_feature = File.expand_path(File.dirname(__FILE__) + "/../fixtures/sample_feature")
+  in_project_folder do
+    `cp -rf #{sample_feature} features/sample.feature`
+  end
+end
+
+After do
+  in_project_folder do
+    Given 'I invoke task "rake culerity:rails:stop"'
+  end
+end

data/features/support/common.rb

@@ -0,0 +1,32 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(options = {})
+    target_path = options[:target_path] || options[:target_file] || options[:target] || 'Rakefile'
+    in_project_folder do
+      contents = File.read(target_path)
+      File.open(target_path, "w+") do |f|
+        f << "$:.unshift('#{@lib_path}')\n"
+        f << contents
+      end
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + "/../../lib/culerity"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root  = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end
+
+require 'rubigen'
+require 'rubigen/helpers/generator_test_helper'
+include RubiGen::GeneratorTestHelper
+require 'rails_generator'
+
+SOURCES = Dir[File.dirname(__FILE__) + "/../../generators"].map do |f|
+  RubiGen::PathSource.new(:test, File.expand_path(f))
+end

data/features/support/matchers.rb

@@ -0,0 +1,11 @@
+module Matchers
+  def contain(expected)
+    simple_matcher("contain #{expected.inspect}") do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to contain #{expected.inspect}"
+      matcher.negative_failure_message = "expected #{given.inspect} not to contain #{expected.inspect}"
+      given.index expected
+    end
+  end
+end
+
+World(Matchers)

data/init.rb

@@ -0,0 +1 @@
+require 'rails/init'

data/lib/culerity.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/culerity/remote_object_proxy'
+require File.dirname(__FILE__) + '/culerity/remote_browser_proxy'
+
+module Culerity
+
+  module ServerCommands
+    def exit_server
+      self << '["_exit_"]'
+      Process.kill(6, self.pid.to_i)
+    end
+
+    def close_browsers
+      self.puts '["_close_browsers_"]'
+    end
+  end
+
+  def self.run_server
+    IO.popen("jruby #{__FILE__}", 'r+').extend(ServerCommands)
+
+    # open the two pipes that were created below
+    # while(!File.exists?("tmp/culerity_in.pipe")) 
+    #   sleep(1)
+    # end
+    # pipe_in = open("tmp/culerity_in.pipe", "w+")
+    # pipe_out = open("tmp/culerity_out.pipe", "r+")
+    
+    
+    
+    # store celerity pid in tmp/culerity_celerity.pid
+    # store server pid in tmp/culerity_rails_server.pid
+    
+    # open named pipes to communicate with celerity_server + return them
+  end
+  
+  def self.run_rails
+    unless File.exists?("tmp/culerity_rails_server.pid")
+      puts "WARNING: Speed up execution by running 'rake culerity:rails:start'"
+      port        = 3001
+      environment = 'culerity_development'
+      puts "Launched rails on :#{port}..."
+      return IO.popen("script/server -e #{environment} -p #{port}", 'r+')
+    end
+  end
+end
+
+if __FILE__ == $0
+  # `rm tmp/culerity_in.pipe`
+  # `mkfifo tmp/culerity_in.pipe`
+  # `rm tmp/culerity_out.pipe`
+  # `mkfifo tmp/culerity_out.pipe`
+  # 
+  # pipe_in = open("tmp/culerity_in.pipe", "r+")
+  # p pipe_in
+  # p STDIN
+  # pipe_out = open("tmp/culerity_out.pipe", "w+")
+  # 
+  require File.dirname(__FILE__) + '/culerity/celerity_server'
+  Culerity::CelerityServer.new STDIN, STDOUT
+end
+

data/lib/culerity/celerity_server.rb

@@ -0,0 +1,81 @@
+require 'rubygems'
+require 'celerity'
+
+
+module Culerity
+  class CelerityServer
+    
+    def initialize(_in, _out)
+      @proxies = {}
+      @browsers = []
+
+      while(true)
+        call = eval _in.gets.to_s.strip
+        return if call == ["_exit_"]
+        next(close_browsers) if call == ["_close_browsers_"]
+        unless call.nil?
+          begin
+            # check if last arg is a block
+            if call.last.is_a?(Proc)
+              # pass as &call[-1]
+              result = target(call.first).send call[1], *call[2..-2], &call[-1]
+            else
+              # just call with args as normal
+              result = target(call.first).send call[1], *call[2..-1]
+            end
+            _out << "[:return, #{proxify result}]\n"
+          rescue => e
+            _out << "[:exception, \"#{e.class.name}\", #{e.message.inspect}, #{e.backtrace.inspect}]\n"
+          end
+        end
+
+      end
+      
+    end
+    
+    private
+    
+    def configure_browser(options)
+      @browser_options = options
+    end
+    
+    def new_browser(options, number = nil)
+      number ||= @browsers.size
+      @browsers[number] = Celerity::Browser.new(options || @browser_options || {})
+      "browser#{number}"
+    end
+
+    def close_browsers
+      @browsers.each { |browser| browser.close }
+      @browsers = []
+    end
+
+    def browser(number)
+      unless @browsers[number]
+        new_browser(nil, number)
+      end
+      @browsers[number]
+    end
+    
+    def target(object_id)
+      if object_id =~ /browser(\d+)/
+        browser($1.to_i)
+      elsif object_id == 'celerity'
+        self
+      else
+        @proxies[object_id]
+      end
+    end
+    
+    def proxify(result, in_array = false)
+      if result.is_a?(Array)
+        result.map {|x| proxify(x, true) }.inspect
+      elsif [String, TrueClass, FalseClass, Fixnum, Float, NilClass].include?(result.class)
+        in_array ? result : result.inspect
+      else
+        @proxies[result.object_id] = result
+        "Culerity::RemoteObjectProxy.new(#{result.object_id}, @io)"
+      end
+    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,25 @@
+class CulerityGenerator < Rails::Generator::Base
+  
+  def manifest
+    record do |m|
+      m.directory 'features/step_definitions'
+      m.file 'features/step_definitions/common_celerity_steps.rb', 'features/step_definitions/common_celerity_steps.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"
+    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!