surveyor 0.20.0 → 0.21.0

data/app/views/partials/_question_group.html.haml

@@ -1,5 +1,5 @@
 - renderer = g.renderer
-- f.inputs q_text(g), :id => "g_#{g.id}", :class => "g_#{renderer} #{g.css_class(@response_set)}" do
+= f.inputs q_text(g), :id => "g_#{g.id}", :class => "g_#{renderer} #{g.css_class(@response_set)}" do
   %li.help= g.help_text
   - case renderer
     - when :grid
@@ -21,7 +21,7 @@
                   - if q.pick == "one"
                     - r = response_for(@response_set, q, nil, g)
                     - i = response_idx  # increment the response index since the answer partial skips for q.pick == one
-                    - f.semantic_fields_for i, r do |ff|
+                    = f.semantic_fields_for i, r do |ff|
                       = ff.quiet_input :question_id
                       = ff.quiet_input :id unless r.new_record?
                   %th= q.split_text(:pre)

data/app/views/partials/_section.html.haml

@@ -1,4 +1,4 @@
-- div_for @section, :class => @section.custom_class do
+= div_for @section, :class => @section.custom_class do
   %span.title= @section.title
   - qs ||= []
   - (questions = @section.questions).each_with_index do |q, i|

data/app/views/surveyor/edit.html.haml

@@ -3,14 +3,22 @@
     .surveyor_flash
       = flash_messages(types)
       .close
-  - semantic_form_for(:r, @response_set, :url => update_my_survey_path, :html => {:method => :put, :id => "survey_form", :class => @survey.custom_class}) do |f|
-    = render 'partials/section_menu' unless @sections.size < 3
+  = semantic_form_for(@response_set, :as => :r, :url => update_my_survey_path, :html => {:method => :put, :id => "survey_form", :class => @survey.custom_class}) do |f|
+  
+    = hidden_field_tag :surveyor_javascript_enabled, false
+  
+    = render 'partials/section_menu' # unless @sections.size < 3
     .survey_title= @survey.title
     .previous_section= previous_section
     = render 'partials/dependents' unless @dependents.empty?
-    - if @response_set.no_responses_for_section?(@section) # cache if response_set has no responses for current section
+    - if false #@response_set.no_responses_for_section?(@section) # cache if response_set has no responses for current section
       = cache("section_#{@section.id}"){ render "/partials/section", :f => f }
     - else # no cache
       = render "/partials/section", :f => f
     .next_section= next_section
   %br
+
+:javascript
+  $(document).ready(function() {
+    $("input#surveyor_javascript_enabled").val(true);
+  });

data/app/views/surveyor/new.html.haml

@@ -10,10 +10,17 @@
       - unless @surveys.empty?
         - @surveys.each do |survey|
           %li
-            - form_tag(take_survey_path(:survey_code => survey.access_code)) do 
+            = form_tag(take_survey_path(:survey_code => survey.access_code)) do 
+              = hidden_field_tag :surveyor_javascript_enabled, false              
+
               = survey.title
                
               = submit_tag( t('surveyor.take_it') )
       - else
         %li
           No surveys
+
+:javascript
+  $(document).ready(function() {
+    $("input#surveyor_javascript_enabled").val(true);
+  });

data/ci-exec.sh

@@ -0,0 +1,50 @@
+#!/bin/bash -xe
+
+BUNDLER_VERSION=1.1.rc
+GEMSET=surveyor
+
+export TMPDIR="`pwd`/tmp"
+mkdir -p tmp
+
+if [ -n "${RAILS_VERSION}" ]; then
+    GEMSET="${GEMSET}-${RAILS_VERSION}"
+fi
+
+if [ -z $CI_RUBY ]; then
+    echo "CI_RUBY must be set"
+    exit 1
+fi
+
+set +xe
+echo "Initializing RVM"
+source ~/.rvm/scripts/rvm
+set -xe
+
+# On the overnight build, reinstall all gems
+if [ `date +%H` -lt 5 ]; then
+    set +xe
+    echo "Purging gemset to verify that all deps can still be installed"
+    rvm --force $CI_RUBY gemset delete $GEMSET
+    set -xe
+fi
+
+RVM_CONFIG="${CI_RUBY}@${GEMSET}"
+set +xe
+echo "Switching to ${RVM_CONFIG}"
+rvm use $RVM_CONFIG
+set -xe
+
+which ruby
+ruby -v
+
+set +e
+gem list -i bundler -v $BUNDLER_VERSION
+if [ $? -ne 0 ]; then
+  set -e
+  gem install bundler -v $BUNDLER_VERSION
+fi
+set -e
+
+bundle _${BUNDLER_VERSION}_ update
+
+bundle _${BUNDLER_VERSION}_ exec rake ci:all --trace

data/config/routes.rb

@@ -1,13 +1,9 @@
-ActionController::Routing::Routes.draw do |map|
-  map.with_options :controller => 'results' do |r|
-    r.results "results", :conditions => {:method => :get}, :action => "index"
-    r.result "results/:survey_code", :conditions => {:method => :get}, :action => "show"
-  end   
-  map.with_options :controller => 'surveyor' do |s|
-    s.available_surveys "surveys",                                        :conditions => {:method => :get}, :action => "new"                      # GET survey list
-    s.take_survey       "surveys/:survey_code",                            :conditions => {:method => :post}, :action => "create"                  # Only POST of survey to create
-    s.view_my_survey    "surveys/:survey_code/:response_set_code.:format", :conditions => {:method => :get}, :action => "show", :format => "html"  # GET viewable/printable? survey
-    s.edit_my_survey    "surveys/:survey_code/:response_set_code/take",    :conditions => {:method => :get}, :action => "edit"                     # GET editable survey 
-    s.update_my_survey  "surveys/:survey_code/:response_set_code",         :conditions => {:method => :put}, :action => "update"                   # PUT edited survey 
-  end
-end
+Rails.application.routes.draw do
+  match 'results', :to                                      => 'results#index', :as   => 'results', :via           => :get
+  match 'results/:survey_code', :to                         => 'results#show', :as    => 'result', :via            => :get
+  match 'surveys', :to                                      => 'surveyor#new', :as    => 'available_surveys', :via => :get
+  match 'surveys/:survey_code', :to                         => 'surveyor#create', :as => 'take_survey', :via       => :post
+  match 'surveys/:survey_code/:response_set_code', :to      => 'surveyor#show', :as   => 'view_my_survey', :via    => :get
+  match 'surveys/:survey_code/:response_set_code/take', :to => 'surveyor#edit', :as   => 'edit_my_survey', :via    => :get
+  match 'surveys/:survey_code/:response_set_code', :to      => 'surveyor#update', :as => 'update_my_survey', :via  => :put
+end                                                                                      

data/cucumber.yml

@@ -0,0 +1,10 @@
+<%
+rerun = File.file?('rerun.txt') ? IO.read('rerun.txt') : ""
+rerun_opts = rerun.to_s.strip.empty? ? "--format #{ENV['CUCUMBER_FORMAT'] || 'progress'} features" : "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} #{rerun}"
+std_opts = "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} --strict --tags ~@wip"
+%>
+default: <%= std_opts %> features
+wip: --tags @wip:3 --wip features
+rerun: <%= rerun_opts %> --format rerun --out rerun.txt --strict --tags ~@wip
+ci: --tags ~@wip --tags ~@javascript --format html --out reports/cucumber.html --format junit --out reports/cucumber-xml --format pretty --strict features
+ci_wip: --wip --tags @wip --tags ~@javascript --format html --out reports/cucumber_wip.html --format pretty features

data/features/redcap_parser.feature

@@ -39,7 +39,7 @@ Feature: Survey creation
       ||
     And there should be 2 answers with:
       ||
-  @focus
+
   Scenario: with different whitespace
     Given I parse redcap file "redcap_whitespace.csv"
     Then there should be 1 survey with:

data/features/step_definitions/common_setps.rb

@@ -0,0 +1,3 @@
+When /^I wait (\d+) seconds$/ do |wait_seconds|
+  sleep(wait_seconds.to_i)
+end

data/features/step_definitions/parser_steps.rb

@@ -3,7 +3,7 @@ Given /^I parse$|^the survey$/ do |string|
 end
 
 Given /^I parse redcap file "([^"]*)"$/ do |name|
-  Surveyor::RedcapParser.parse File.read(File.join(RAILS_ROOT, '..', 'features', 'support', name)), name
+  Surveyor::RedcapParser.parse File.read(File.join(Rails.root, '..', 'features', 'support', name)), name
 end
 
 Then /^there should be (\d+) survey(?:s?) with:$/ do |x, table|
@@ -13,6 +13,13 @@ Then /^there should be (\d+) survey(?:s?) with:$/ do |x, table|
   end
 end
 
+Then /^there should be (\d+) section(?:s?) with:$/ do |x, table|
+  SurveySection.count.should == x.to_i
+  table.hashes.each do |hash|
+    SurveySection.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
 Then /^there should be (\d+) question groups with:$/ do |x, table|
   QuestionGroup.count.should == x.to_i
   table.hashes.each do |hash|

data/features/step_definitions/surveyor_steps.rb

@@ -17,7 +17,7 @@ Then /^there should be (\d+) response set with (\d+) responses? with:$/ do |rs_n
         Response.first(:conditions => hash.merge({:answer_id => answer.id})).should_not be_nil
       elsif
         Response.first(:conditions => hash).should_not be_nil
-      end      
+      end
     end
   end
 end
@@ -34,7 +34,11 @@ Then /^question "([^"]*)" should have a dependency with rule "([^"]*)"$/ do |qr,
 end
 
 Then /^the element "([^"]*)" should have the class "([^"]*)"$/ do |selector, css_class|
-  response.should have_selector(selector, :class => css_class)
+  page.should have_selector(selector, :class => css_class)
+end
+
+Then /^the element "([^"]*)" should exist$/ do |selector|
+  page.should have_selector(selector)
 end
 
 Then /^the survey should be complete$/ do
@@ -42,7 +46,7 @@ Then /^the survey should be complete$/ do
 end
 
 Then /^a dropdown should exist with the options "([^"]*)"$/ do |options_text|
-  response.should have_selector('select')
+  page.should have_selector('select')
   options = options_text.split(',').collect(&:strip)
   within "select" do |select|
     options.each do |o|
@@ -52,16 +56,15 @@ Then /^a dropdown should exist with the options "([^"]*)"$/ do |options_text|
 end
 
 Then /^there should be (\d+) checkboxes$/ do |count|
-  response.should have_selector('input[type=checkbox]', :count => count.to_i)
-  
+  page.should have_selector('input[type=checkbox]', :count => count.to_i)
 end
 
 Then /^there should be (\d+) text areas$/ do |count|
-  response.should have_selector('textarea', :count => count.to_i)
+  page.should have_selector('textarea', :count => count.to_i)
 end
 
 Then /^the question "([^"]*)" should be triggered$/ do |text|
-  response.should have_selector %(fieldset[name="#{text}"][class!="q_hidden"])
+  page.should have_selector %(fieldset[name="#{text}"][class!="q_hidden"])
 end
 
 Then /^there should be (\d+) response with answer "([^"]*)"$/ do |count, answer_text|
@@ -73,11 +76,32 @@ Then /^there should be (\d+) datetime responses with$/ do |count, table|
   Response.count.should == count.to_i
   table.hashes.each do |hash|
     if hash.keys == ["datetime_value"]
-      Response.find_by_datetime_value(DateTime.parse(hash["datetime_value"])).should_not be_blank
+      dtv = DateTime.parse( hash["datetime_value"].size == 8 ? "0001-01-01 #{hash['datetime_value']}" : hash["datetime_value"])
+      Response.all.one?{|x| x.datetime_value == dtv}.should be_true
     end
   end
 end
 
 Then /^I should see the image "([^"]*)"$/ do |src|
-  response.should have_selector %(img[src^="#{src}"])
+  page.should have_selector %(img[src^="#{src}"])
 end
+
+Then /^(\d+) responses should exist$/ do |response_count|
+  Response.count.should == response_count.to_i
+end
+
+Then /the element "([^\"]*)" should be hidden$/ do |selector|
+  wait_until do
+    its_hidden = page.evaluate_script("$('#{selector}').is(':hidden');")
+    its_not_in_dom = page.evaluate_script("$('#{selector}').length == 0;")
+    (its_hidden || its_not_in_dom).should be_true
+  end
+end
+
+Then /the element "([^\"]*)" should not be hidden$/ do |selector|
+  wait_until do
+    its_not_hidden = page.evaluate_script("$('#{selector}').is(':not(:hidden)');")
+    its_in_dom = page.evaluate_script("$('#{selector}').length > 0;")
+    (its_not_hidden && its_in_dom).should be_true
+  end
+end

data/features/step_definitions/web_steps.rb

@@ -1,16 +1,45 @@
-# IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
-# It is recommended to regenerate this file in the future when you upgrade to a 
-# newer version of cucumber-rails. Consider adding your own code to a new file 
-# instead of editing this one. Cucumber will automatically load all features/**/*.rb
-# files.
+# TL;DR: YOU SHOULD DELETE THIS FILE
+#
+# This file was generated by Cucumber-Rails and is only here to get you a head start
+# These step definitions are thin wrappers around the Capybara/Webrat API that lets you
+# visit pages, interact with widgets and make assertions about page content.
+#
+# If you use these step definitions as basis for your features you will quickly end up
+# with features that are:
+#
+# * Hard to maintain
+# * Verbose to read
+#
+# A much better approach is to write your own higher level step definitions, following
+# the advice in the following blog posts:
+#
+# * http://benmabey.com/2008/05/19/imperative-vs-declarative-scenarios-in-user-stories.html
+# * http://dannorth.net/2011/01/31/whose-domain-is-it-anyway/
+# * http://elabs.se/blog/15-you-re-cuking-it-wrong
+#
 
 
 require 'uri'
 require 'cgi'
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "selectors"))
 
-# Commonly used webrat steps
-# http://github.com/brynary/webrat
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(*selector_for(locator)) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+# Single-line step scoper
+When /^(.*) within (.*[^:])$/ do |step, parent|
+  with_scope(parent) { When step }
+end
+
+# Multi-line step scoper
+When /^(.*) within (.*[^:]):$/ do |step, parent, table_or_string|
+  with_scope(parent) { When "#{step}:", table_or_string }
+end
 
 Given /^(?:|I )am on (.+)$/ do |page_name|
   visit path_to(page_name)
@@ -28,28 +57,14 @@ When /^(?:|I )follow "([^"]*)"$/ do |link|
   click_link(link)
 end
 
-When /^(?:|I )follow "([^"]*)" within "([^"]*)"$/ do |link, parent|
-  click_link_within(parent, link)
-end
-
 When /^(?:|I )fill in "([^"]*)" with "([^"]*)"$/ do |field, value|
-  field = resolve_regexp(field)
   fill_in(field, :with => value)
 end
 
 When /^(?:|I )fill in "([^"]*)" for "([^"]*)"$/ do |value, field|
-  field = resolve_regexp(field)
   fill_in(field, :with => value)
 end
 
-def resolve_regexp(expr)
-  if expr =~ /\/.*\//
-    Regexp.new(expr[1..-2])
-  else
-    expr
-  end
-end
-
 # Use this to fill in an entire form with data from a table. Example:
 #
 #   When I fill in the following:
@@ -71,53 +86,6 @@ When /^(?:|I )select "([^"]*)" from "([^"]*)"$/ do |value, field|
   select(value, :from => field)
 end
 
-# Use this step in conjunction with Rail's datetime_select helper. For example:
-# When I select "December 25, 2008 10:00" as the date and time
-When /^(?:|I )select "([^"]*)" as the date and time$/ do |time|
-  select_datetime(time)
-end
-
-# Use this step when using multiple datetime_select helpers on a page or
-# you want to specify which datetime to select. Given the following view:
-#   <%= f.label :preferred %><br />
-#   <%= f.datetime_select :preferred %>
-#   <%= f.label :alternative %><br />
-#   <%= f.datetime_select :alternative %>
-# The following steps would fill out the form:
-# When I select "November 23, 2004 11:20" as the "Preferred" date and time
-# And I select "November 25, 2004 10:30" as the "Alternative" date and time
-When /^(?:|I )select "([^"]*)" as the "([^"]*)" date and time$/ do |datetime, datetime_label|
-  select_datetime(datetime, :from => datetime_label)
-end
-
-# Use this step in conjunction with Rail's time_select helper. For example:
-# When I select "2:20PM" as the time
-# Note: Rail's default time helper provides 24-hour time-- not 12 hour time. Webrat
-# will convert the 2:20PM to 14:20 and then select it.
-When /^(?:|I )select "([^"]*)" as the time$/ do |time|
-  select_time(time)
-end
-
-# Use this step when using multiple time_select helpers on a page or you want to
-# specify the name of the time on the form.  For example:
-# When I select "7:30AM" as the "Gym" time
-When /^(?:|I )select "([^"]*)" as the "([^"]*)" time$/ do |time, time_label|
-  select_time(time, :from => time_label)
-end
-
-# Use this step in conjunction with Rail's date_select helper.  For example:
-# When I select "February 20, 1981" as the date
-When /^(?:|I )select "([^"]*)" as the date$/ do |date|
-  select_date(date)
-end
-
-# Use this step when using multiple date_select helpers on one page or
-# you want to specify the name of the date on the form. For example:
-# When I select "April 26, 1982" as the "Date of Birth" date
-When /^(?:|I )select "([^"]*)" as the "([^"]*)" date$/ do |date, date_label|
-  select_date(date, :from => date_label)
-end
-
 When /^(?:|I )check "([^"]*)"$/ do |field|
   check(field)
 end
@@ -130,140 +98,92 @@ When /^(?:|I )choose "([^"]*)"$/ do |field|
   choose(field)
 end
 
-# Adds support for validates_attachment_content_type. Without the mime-type getting
-# passed to attach_file() you will get a "Photo file is not one of the allowed file types."
-# error message 
 When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"$/ do |path, field|
-  type = path.split(".")[1]
-
-  case type
-  when "jpg"
-    type = "image/jpg" 
-  when "jpeg"
-    type = "image/jpeg" 
-  when "png"
-    type = "image/png" 
-  when "gif"
-    type = "image/gif"
-  end
-  
-  attach_file(field, path, type)
+  attach_file(field, File.expand_path(path))
 end
 
 Then /^(?:|I )should see "([^"]*)"$/ do |text|
-  if response.respond_to? :should
-    response.should contain(text)
+  if page.respond_to? :should
+    page.should have_content(text)
   else
-    assert_contain text
-  end
-end
-
-Then /^(?:|I )should see "([^"]*)" within "([^"]*)"$/ do |text, selector|
-  within(selector) do |content|
-    if content.respond_to? :should
-      content.should contain(text)
-    else
-      hc = Webrat::Matchers::HasContent.new(text)
-      assert hc.matches?(content), hc.failure_message
-    end
+    assert page.has_content?(text)
   end
 end
 
 Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
   regexp = Regexp.new(regexp)
-  if response.respond_to? :should
-    response.should contain(regexp)
-  else
-    assert_match(regexp, response_body)
-  end
-end
 
-Then /^(?:|I )should see \/([^\/]*)\/ within "([^"]*)"$/ do |regexp, selector|
-  within(selector) do |content|
-    regexp = Regexp.new(regexp)
-    if content.respond_to? :should
-      content.should contain(regexp)
-    else
-      assert_match(regexp, content)
-    end
+  if page.respond_to? :should
+    page.should have_xpath('//*', :text => regexp)
+  else
+    assert page.has_xpath?('//*', :text => regexp)
   end
 end
 
 Then /^(?:|I )should not see "([^"]*)"$/ do |text|
-  if response.respond_to? :should_not
-    response.should_not contain(text)
+  if page.respond_to? :should
+    page.should have_no_content(text)
   else
-    assert_not_contain(text)
-  end
-end
-
-Then /^(?:|I )should not see "([^"]*)" within "([^"]*)"$/ do |text, selector|
-  within(selector) do |content|
-    if content.respond_to? :should_not
-      content.should_not contain(text)
-    else
-      hc = Webrat::Matchers::HasContent.new(text)
-      assert !hc.matches?(content), hc.negative_failure_message
-    end
+    assert page.has_no_content?(text)
   end
 end
 
 Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
   regexp = Regexp.new(regexp)
-  if response.respond_to? :should_not
-    response.should_not contain(regexp)
+
+  if page.respond_to? :should
+    page.should have_no_xpath('//*', :text => regexp)
   else
-    assert_not_contain(regexp)
+    assert page.has_no_xpath?('//*', :text => regexp)
   end
 end
 
-Then /^(?:|I )should not see \/([^\/]*)\/ within "([^"]*)"$/ do |regexp, selector|
-  within(selector) do |content|
-    regexp = Regexp.new(regexp)
-    if content.respond_to? :should_not
-      content.should_not contain(regexp)
+Then /^the "([^"]*)" field(?: within (.*))? should contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
     else
-      assert_no_match(regexp, content)
+      assert_match(/#{value}/, field_value)
     end
   end
 end
 
-Then /^the "([^"]*)" field should contain "([^"]*)"$/ do |field, value|
-  field_value = field_labeled(field).value
-  if field_value.respond_to? :should
-    field_value.should =~ /#{value}/
-  else
-    assert_match(/#{value}/, field_value)
-  end
-end
-
-Then /^the "([^"]*)" field should not contain "([^"]*)"$/ do |field, value|
-  field_value = field_labeled(field).value
-  if field_value.respond_to? :should_not
-    field_value.should_not =~ /#{value}/
-  else
-    assert_no_match(/#{value}/, field_value)
+Then /^the "([^"]*)" field(?: within (.*))? should not contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should_not
+      field_value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field_value)
+    end
   end
 end
 
-Then /^the "([^"]*)" checkbox should be checked$/ do |label|
-  field = field_labeled(label)
-  if field.respond_to? :should
-    field.should be_checked
-  else
-    assert field.checked?
+Then /^the "([^"]*)" checkbox(?: within (.*))? should be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_true
+    else
+      assert field_checked
+    end
   end
 end
 
-Then /^the "([^"]*)" checkbox should not be checked$/ do |label|
-  field = field_labeled(label)
-  if field.respond_to? :should_not
-    field.should_not be_checked
-  else
-    assert !field.checked?
+Then /^the "([^"]*)" checkbox(?: within (.*))? should not be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_false
+    else
+      assert !field_checked
+    end
   end
 end
-
+ 
 Then /^(?:|I )should be on (.+)$/ do |page_name|
   current_path = URI.parse(current_url).path
   if current_path.respond_to? :should
@@ -278,7 +198,7 @@ Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
   actual_params = query ? CGI.parse(query) : {}
   expected_params = {}
   expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')} 
-
+  
   if actual_params.respond_to? :should
     actual_params.should == expected_params
   else