noodall-form-builder 0.0.1

data/features/step_definitions/form_builder_steps.rb

@@ -0,0 +1,247 @@
+When /^I visit the form builder admin page$/ do
+  visit noodall_admin_forms_path
+end
+
+Then /^I should see a form with at least the following fields:$/ do |table|
+  table.rows.each do |row|
+    page.should have_selector("input[value='#{row[0]}']")
+  end
+end
+
+When /^I fill the following fields:$/ do |table|
+  table.rows.each do |row|
+    @new_form_name = row[1] if @new_form_name.nil?
+    fill_in row[0], :with => row[1]
+  end
+end
+
+When /^I add the fields I want on the form$/ do
+# Some selenium dodads here
+
+#  5.times do |i|
+#    #get index of new fieldset
+#    index = 1
+#    response.should have_selector('#form-fields fieldset') do |fieldset|
+#      index += 1
+#    end
+#    click_link_within 'div#main-form', 'Add'
+#    save_and_open_page
+#
+#    within "fieldset#field-#{index}" do |fieldset|
+#      fieldset.fill_in 'Name', :with => "Field #{i}"
+#    end
+#  end
+end
+
+Then /^I should see the new form in the Form List$/ do
+  page.should have_content(@new_form_name)
+end
+
+Given /^I am creating a form$/ do
+  visit new_noodall_admin_form_path
+end
+
+Then /^I should see a new field with the options "([^\"]*)"$/ do |arg1|
+  #get index of new fieldset
+  index = 0
+  page.should have_selector('#form-fields fieldset') do |fieldset|
+    index += 1
+  end
+
+  page.should have_selector("fieldset#field-#{index}")
+end
+
+Given /^a form exists that has had many responses$/ do
+  form = Factory(:form)
+
+  responses = []
+  9.times do |i|
+    responses << Factory(:response)
+  end
+  form.responses = responses
+  form.save!
+end
+
+When /^I click "([^\"]*)" on the forms row in the Form List$/ do |arg1|
+  within('#content-table table tbody tr:first-child') do
+    click_link arg1
+  end
+end
+
+Then /^I should receive a CSV file containing all the responses to that form$/ do
+  CSV.parse(page.body).should have(10).things # 9 rows plus header
+end
+
+
+Given /^forms have been created with the form builder$/ do
+  5.times do
+    Factory(:form)
+  end
+end
+
+Then /^I should see a form select element containing the exisitng forms$/ do
+  Noodall::Form.all.each do |form|
+    page.should have_selector("select#node_wide_slot_0_form_id option:contains('#{form.title}')")
+  end
+end
+
+When /^I select a form$/ do
+  @_form = Noodall::Form.first
+  select @_form.title, :from => 'Form'
+end
+
+Then /^I should see the form I selected$/ do
+  @_form.fields.each do |field|
+    page.should have_selector("label[for=form_response_#{field.underscored_name}]")
+  end
+end
+
+Given /^a form exists$/ do
+  Factory(:form)
+end
+
+Given /^content exists with a form added via the contact module$/ do
+  @_node = Factory(:page_a)
+  @_form = Factory(:form)
+  @_node.wide_slot_0 = Factory(:contact_form, :form_id => @_form.id)
+  @_node.save
+end
+
+When /^a website visitor visits the content$/ do
+  visit node_path(@_node)
+end
+
+Then /^they should see the form$/ do
+  Then %{I should see the form I selected}
+end
+
+When /^they fill in and submit the form$/ do
+  @_form = Noodall::Form.find(@_node.wide_slot_0.form_id)
+  @_form.fields.each do |field|
+    if field.name == 'Email'
+      fill_in "form_response[#{field.underscored_name}]", :with => 'hello@example.com'
+    else
+      fill_in "form_response[#{field.underscored_name}]", :with => 'Weopunggggggggst'
+    end
+  end
+
+  When %{they submit the form}
+end
+
+Then /^the email address of the form should receive an email detailing the information submitted$/ do
+  Then %{"#{@_form.email}" should receive an email}
+  @_form.fields do |field|
+    Then %{they should see "#{field.name}:" in the email body}
+  end
+end
+
+Then /^they should receive an email confirming the request has been sent$/ do
+  Then %{"hello@example.com" should receive an email}
+  @_form.fields do |field|
+    Then %{they should see "#{field.name}:" in the email body}
+  end
+end
+
+Then /^the response should be stored in the database along with the time submitted, IP address, and page it was submitted from$/ do
+  @_form.reload
+  @response = @_form.responses.last
+
+  @response.created_at.should_not be nil
+  @response.ip.should == '127.0.0.1'
+  @response.referrer.should == node_url(@_node)
+end
+
+Then /^it should be checked by a spam filter$/ do
+  #err
+end
+
+Then /^it should be rejected if the spam filter deems the response to be spam$/ do
+  within('form #errorExplanation') do
+    page.should have_content('spam')
+  end
+end
+
+Then /^the website visitor should see an spam message$/ do
+  Then %{it should be rejected if the spam filter deems the response to be spam}
+end
+
+Then /^it should be checked against the validation speficied in the form builder$/ do
+  @_form.required_fields.each do |field|
+    within('#errorExplanation') do
+      page.should have_content(field.name)
+    end
+  end
+end
+
+Then /^it should be rejected if the the response does not meet the validation$/ do
+  Then %{it should be checked against the validation speficied in the form builder}
+end
+
+Then /^the website visitor should see an error message$/ do
+    page.should have_selector('form #errorExplanation')
+end
+
+When /^a website visitor fills in and submits a form$/ do
+  When %{they fill in and submit the form}
+end
+
+When /^they submit the form$/ do
+  click_button 'Send'
+end
+
+When /^a form response is deemed to be spam$/ do
+  When %{a website visitor visits the content}
+  defensio_dummy = double("defensio dummy")
+  defensio_dummy.stub(:post_document){ [200, {:spaminess => 1}] }
+
+  Noodall::FormResponse.stub(:defensio).and_return(defensio_dummy)
+  When %{they fill in and submit the form}
+end
+
+Then /^it should marked as spam$/ do
+  Noodall::Form.last.responses.last.approved.should == false
+end
+
+When /^I click "([^"]*)"$/ do |arg1|
+  click_link(arg1)
+end
+
+Given /^a form exists with the following fields:$/ do |table|
+  fields = table.rows_hash.map do |name, type|
+    factory, opts = type.split(': ')
+    if opts.blank?
+      Factory(factory.parameterize('_'), :name => name)
+    else
+      Factory(factory.parameterize('_'), :name => name, :options => opts)
+    end
+  end
+  @_form = Factory(:form, :fields => fields)
+end
+
+When /^I am editing the form$/ do
+  visit noodall_admin_form_path(@_form)
+end
+
+When /^I click the "([^"]*)" arrow next to "([^"]*)" twice$/ do |arg1, arg2|
+  pending # express the regexp above with the code you wish you had
+end
+
+Then /^the "([^"]*)" field should be at position (\d+)$/ do |arg1, arg2|
+  pending # express the regexp above with the code you wish you had
+end
+
+When /^I click the "([^"]*)" arrow next to "([^"]*)" once$/ do |arg1, arg2|
+  pending # express the regexp above with the code you wish you had
+end
+
+When /^I view the form on the website$/ do
+  @_node = Factory(:page_a)
+  @_node.wide_slot_0 = Factory(:contact_form, :form_id => @_form.id)
+  @_node.save
+  When %{a website visitor visits the content}
+end
+
+Then /^I should see the fields in the order I set$/ do
+  pending # express the regexp above with the code you wish you had
+end
+

data/features/step_definitions/sign_in_steps.rb

@@ -0,0 +1,48 @@
+Given /^I am signed in(?: as an? (.*))?$/ do |role|
+  role ||= 'user'
+  role = role.strip.gsub(/\W/,'_')
+
+  user = Factory(role)
+  Given %{I sign in as "#{user.email}/#{user.password}"}
+end
+
+Then /^I should see a list of users$/ do
+  page.should have_css('tbody tr', :count => 20)
+end
+
+# Database
+
+Given /^a user exists with the attrubutes:$/ do |fields|
+  user = Factory :user, fields.rows_hash
+end
+
+Given /^I sign in as a (.+)$/ do |role|
+  user = create_model(role).first
+  user.confirm_email!
+  Given %{I sign in as "#{user.email}\/#{user.password}"}
+end
+
+# Actions
+
+When /^I sign in as "(.*)\/(.*)"$/ do |email, password|
+  When %{I go to the sign in page}
+  And %{I fill in "user_email" with "#{email}"}
+  And %{I fill in "user_password" with "#{password}"}
+  And %{I press "Sign in"}
+end
+
+When /^I sign out$/ do
+  visit destroy_user_session_path
+end
+
+Then /^the user should (not )?be able to sign in as "(.*)\/(.*)"$/ do |yes_no, email, password|
+  Given %{I sign out}
+  And %{I sign in as "#{email}/#{password}"}
+  if yes_no.blank?
+    Then %{I should see "Signed in successfully"}
+  else
+    Then %{I should see "Invalid email or password."}
+  end
+end
+
+

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,219 @@
+# 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.
+
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(locator) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^"]*)"(?: within "([^"]*)")?$/ do |button, selector|
+  with_scope(selector) do
+    click_button(button)
+  end
+end
+
+When /^(?:|I )follow "([^"]*)"(?: within "([^"]*)")?$/ do |link, selector|
+  with_scope(selector) do
+    click_link(link)
+  end
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"(?: within "([^"]*)")?$/ do |field, value, selector|
+  with_scope(selector) do
+    fill_in(field, :with => value)
+  end
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"(?: within "([^"]*)")?$/ do |value, field, selector|
+  with_scope(selector) do
+    fill_in(field, :with => value)
+  end
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following(?: within "([^"]*)")?:$/ do |selector, fields|
+  with_scope(selector) do
+    fields.rows_hash.each do |name, value|
+      When %{I fill in "#{name}" with "#{value}"}
+    end
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"(?: within "([^"]*)")?$/ do |value, field, selector|
+  with_scope(selector) do
+    select(value, :from => field)
+  end
+end
+
+When /^(?:|I )check "([^"]*)"(?: within "([^"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    check(field)
+  end
+end
+
+When /^(?:|I )uncheck "([^"]*)"(?: within "([^"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    uncheck(field)
+  end
+end
+
+When /^(?:|I )choose "([^"]*)"(?: within "([^"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    choose(field)
+  end
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"(?: within "([^"]*)")?$/ do |path, field, selector|
+  with_scope(selector) do
+    attach_file(field, path)
+  end
+end
+
+Then /^(?:|I )should see JSON:$/ do |expected_json|
+  require 'json'
+  expected = JSON.pretty_generate(JSON.parse(expected_json))
+  actual   = JSON.pretty_generate(JSON.parse(response.body))
+  expected.should == actual
+end
+
+Then /^(?:|I )should see "([^"]*)"(?: within "([^"]*)")?$/ do |text, selector|
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_content(text)
+    else
+      assert page.has_content?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/(?: within "([^"]*)")?$/ do |regexp, selector|
+  regexp = Regexp.new(regexp)
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_xpath('//*', :text => regexp)
+    else
+      assert page.has_xpath?('//*', :text => regexp)
+    end
+  end
+end
+
+Then /^(?:|I )should not see "([^"]*)"(?: within "([^"]*)")?$/ do |text, selector|
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_no_content(text)
+    else
+      assert page.has_no_content?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/(?: within "([^"]*)")?$/ do |regexp, selector|
+  regexp = Regexp.new(regexp)
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_no_xpath('//*', :text => regexp)
+    else
+      assert page.has_no_xpath?('//*', :text => regexp)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: within "([^"]*)")? should contain "([^"]*)"$/ do |field, selector, value|
+  with_scope(selector) 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_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: within "([^"]*)")? should not contain "([^"]*)"$/ do |field, selector, value|
+  with_scope(selector) 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(?: within "([^"]*)")? should be checked$/ do |label, selector|
+  with_scope(selector) 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(?: within "([^"]*)")? should not be checked$/ do |label, selector|
+  with_scope(selector) 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
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  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
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end

data/features/support/defensio_mock.rb

@@ -0,0 +1,6 @@
+Before do
+  defensio_dummy = double("defensio dummy")
+  defensio_dummy.stub(:post_document){ [200, {:spaminess => 0.2}] }
+
+  Noodall::FormResponse.stub(:defensio).and_return(defensio_dummy)
+end

data/features/support/env.rb

@@ -0,0 +1,52 @@
+# 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.
+
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path("../../../spec/dummy/config/environment.rb",  __FILE__)
+
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'cucumber/rails/rspec'
+require 'cucumber/rails/world'
+require 'email_spec/cucumber'
+require 'cucumber/web/tableish'
+require 'cucumber/rspec/doubles'
+
+require 'capybara/rails'
+require 'capybara/cucumber'
+require 'capybara/session'
+# Capybara defaults to XPath selectors rather than Webrat's default of CSS3. In
+# order to ease the transition to Capybara we set the default here. If you'd
+# prefer to use XPath just remove this line and adjust any selectors in your
+# steps to use the XPath syntax.
+Capybara.default_selector = :css
+
+# If you set this to false, any error raised from within your app will bubble
+# up to your step definition and out to cucumber unless you catch it somewhere
+# on the way. You can make Rails rescue errors and render error pages on a
+# per-scenario basis by tagging a scenario or feature with the @allow-rescue tag.
+#
+# If you set this to true, Rails will rescue all errors and render error
+# pages, more or less in the same way your application would behave in the
+# default production environment. It's not recommended to do this for all
+# of your scenarios, as this makes it hard to discover errors in your application.
+ActionController::Base.allow_rescue = false
+
+# How to clean your database when transactions are turned off. See
+# http://github.com/bmabey/database_cleaner for more info.
+require 'database_cleaner'
+require 'database_cleaner/cucumber'
+DatabaseCleaner.strategy = :truncation
+
+require 'factory_girl'
+
+Factory.definition_file_paths = [
+  File.expand_path("../../../spec/factories",  __FILE__)
+]
+Factory.find_definitions
+
+require 'factory_girl/step_definitions'
+require 'csv' #for checking CSV content
+

data/features/support/paths.rb

@@ -0,0 +1,60 @@
+require 'noodall/permalinks'
+
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+
+    when /the (home\s?page|website)/i
+      root_path
+    when /the CMS/
+      '/admin'
+    when /the sign in page/
+      new_user_session_path
+    when /^the (?:root )?content titled "([^\"]*)" page$/i
+      node = Node.find_by_title($1)
+      node_path(node)
+    when /^the content admin page$/
+      noodall_admin_nodes_path
+    when /^the site ?map page$/
+      noodall_sitemap_path
+    when /^a page that's content is in the "([^\"]*)" template$/
+      node = Node.first(:_type => $1.gsub(' ',''), :order => 'created_at DESC')
+      node_path(node)
+    when /^a page that's content is in the "([^\"]*)" template that does not have published children$/
+      node = Factory($1.gsub(' ','_').tableize.singularize, :publish => true)
+      node.children.each{|c| c.destroy }
+      node_path(node)
+    when /^a page that's content is in the "([^\"]*)" template that has published children$/
+      node = Factory($1.gsub(' ','_').tableize.singularize, :publish => true)
+      3.times do
+        Factory(:page_a, :publish => true, :parent => node)
+      end
+      node_path(node)
+    when /^that page$/
+      node_path(@_content)
+
+    when /^the article list page$/
+      node_path(@_content)
+    when /content titled "([^\"]*)"$/
+      node_path(Node.find_by_title($1))
+    else
+      begin
+        page_name =~ /the (.*) page/
+        path_components = $1.split(/\s+/)
+        self.send(path_components.push('path').join('_').to_sym)
+      rescue Object => e
+        raise "Can't find a mapping from \"#{page_name}\" to a path.\n" +
+          "Please add one to #{__FILE__}"
+      end
+    end
+  end
+end
+
+World(NavigationHelpers)
+World(Noodall::Permalinks)

data/lib/noodall/form_builder/engine.rb

@@ -0,0 +1,13 @@
+module Noodall
+  module FormBuilder
+    class Engine < Rails::Engine
+      initializer "set menu" do |app|
+        Noodall::UI.menu_items['Forms'] = :noodall_admin_forms_path
+      end
+      
+      initializer "static assets" do |app|
+        app.middleware.use ::ActionDispatch::Static, "#{root}/public"
+      end
+    end
+  end
+end

data/lib/noodall/form_builder/routes.rb

@@ -0,0 +1,35 @@
+module Noodall
+  module FormBuilder
+    class Routes
+      class << self
+        def draw(app)
+          app.routes.draw do
+  
+            namespace 'noodall', :as => 'noodall', :path => '' do
+              resources :forms do
+                resources :form_responses
+              end
+            end
+          
+            namespace 'noodall/admin', :as => 'noodall_admin', :path => 'admin' do
+              resources :forms do
+                resources :form_responses do
+                  member do
+                    get :mark_as_spam
+                  end
+                end
+              end
+              
+              resources :fields do
+                collection do
+                  get :form
+                end
+              end
+              match 'components/form/:type' => 'components#form'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/noodall/form_builder/version.rb

@@ -0,0 +1,5 @@
+module Noodall
+  module FormBuilder
+    VERSION = "0.0.1"
+  end
+end

data/lib/noodall-form-builder.rb

@@ -0,0 +1 @@
+require 'noodall/form_builder/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3