adva-core 0.0.9 → 0.0.13

data/lib/patches/rails/recognize_path_env.rb

@@ -1,41 +1,45 @@
-require 'action_dispatch/routing/mapper'
-require 'action_dispatch/routing/route_set'
-
 # make recognize_path pass the given environment through
+#
+# FIXME: patch this better, do not override the whole method
 
-module ActionDispatch
-  module Routing
-    class RouteSet
-      def recognize_path(path, environment = {})
-        method = (environment[:method] || "GET").to_s.upcase
-        path = Rack::Mount::Utils.normalize_path(path)
+Gem.patching('rails', '3.0.9') do
+  require 'action_dispatch/routing/mapper'
+  require 'action_dispatch/routing/route_set'
 
-        begin
-          # env = Rack::MockRequest.env_for(path, {:method => method})
-          env = Rack::MockRequest.env_for(path, {:method => method}).merge(environment)
-        rescue URI::InvalidURIError => e
-          raise ActionController::RoutingError, e.message
-        end
+  module ActionDispatch
+    module Routing
+      class RouteSet
+        def recognize_path(path, environment = {})
+          method = (environment[:method] || "GET").to_s.upcase
+          path = Rack::Mount::Utils.normalize_path(path)
 
-        req = Rack::Request.new(env)
-        @set.recognize(req) do |route, matches, params|
-          params.each do |key, value|
-            if value.is_a?(String)
-              value = value.dup.force_encoding(Encoding::BINARY) if value.encoding_aware?
-              params[key] = URI.unescape(value)
-            end
+          begin
+            # env = Rack::MockRequest.env_for(path, {:method => method})
+            env = Rack::MockRequest.env_for(path, {:method => method}).merge(environment)
+          rescue URI::InvalidURIError => e
+            raise ActionController::RoutingError, e.message
           end
 
-          dispatcher = route.app
-          dispatcher = dispatcher.app while dispatcher.is_a?(Mapper::Constraints)
+          req = Rack::Request.new(env)
+          @set.recognize(req) do |route, matches, params|
+            params.each do |key, value|
+              if value.is_a?(String)
+                value = value.dup.force_encoding(Encoding::BINARY) if value.encoding_aware?
+                params[key] = URI.unescape(value)
+              end
+            end
+
+            dispatcher = route.app
+            dispatcher = dispatcher.app while dispatcher.is_a?(Mapper::Constraints)
 
-          if dispatcher.is_a?(Dispatcher) && dispatcher.controller(params, false)
-            dispatcher.prepare_params!(params)
-            return params
+            if dispatcher.is_a?(Dispatcher) && dispatcher.controller(params, false)
+              dispatcher.prepare_params!(params)
+              return params
+            end
           end
-        end
 
-        raise ActionController::RoutingError, "No route matches #{path.inspect}"
+          raise ActionController::RoutingError, "No route matches #{path.inspect}"
+        end
       end
     end
   end

data/lib/patches/rails/route_set_to_param.rb

@@ -2,24 +2,26 @@
 # if arity allows it. so we can use param names in routes and distinguish them
 # in the model.
 
-require 'action_dispatch/routing/route_set'
+Gem.patching('rails', '3.0.9') do
+  require 'action_dispatch/routing/route_set'
 
-ActionDispatch::Routing::RouteSet::Generator.class_eval do
-  def opts
-    parameterize = lambda do |name, value|
-      if name == :controller
-        value
-      elsif value.is_a?(Array)
-        value.map { |v| Rack::Mount::Utils.escape_uri(to_param(name, v)) }.join('/')
-      else
-        return nil unless param = to_param(name, value)
-        param.split('/').map { |v| Rack::Mount::Utils.escape_uri(v) }.join("/")
+  ActionDispatch::Routing::RouteSet::Generator.class_eval do
+    def opts
+      parameterize = lambda do |name, value|
+        if name == :controller
+          value
+        elsif value.is_a?(Array)
+          value.map { |v| Rack::Mount::Utils.escape_uri(to_param(name, v)) }.join('/')
+        else
+          return nil unless param = to_param(name, value)
+          param.split('/').map { |v| Rack::Mount::Utils.escape_uri(v) }.join("/")
+        end
       end
+      {:parameterize => parameterize}
+    end
+
+    def to_param(name, value)
+      value.method(:to_param).arity == 0 ? value.to_param : value.to_param(name)
     end
-    {:parameterize => parameterize}
-  end
-  
-  def to_param(name, value)
-    value.method(:to_param).arity == 1 ? value.to_param(name) : value.to_param
   end
-end
+end

data/lib/patches/rails/route_set_trailing_segment.rb

@@ -1,7 +1,7 @@
 require 'gem-patching'
 
 # remove trailing segments '.1' and  query params '?=1' from url
-Gem.patching('rails', '3.0.3') do
+Gem.patching('rails', '3.0.9') do
   ActionDispatch::Routing::RouteSet.class_eval do
     def url_for_with_singleton_resource_patch(options)
       url_for_without_singleton_resource_patch(options).

data/lib/patches/rails/sti_associations.rb

@@ -4,13 +4,19 @@ require 'gem-patching'
 # i.e.: site.sections.build(:type => 'Page').class == Page
 # http://pragmatig.com/2010/06/04/fixing-rails-nested-attributes-on-collections-with-sti
 
-Gem.patching('rails', '3.0.3') do
+Gem.patching('rails', '3.0.9') do
   class ActiveRecord::Reflection::AssociationReflection
-    def build_association(*options)
+    def build_association(*options, &block)
       if options.first.is_a?(Hash) && options.first[:type].present?
-        options.first[:type].to_s.constantize.new(*options)
+        requested_class = options.first[:type].to_s.constantize
+        if requested_class <= klass
+          requested_class.new(*options, &block)
+        else
+          # do not allow to create random record, for example User with role admin
+          raise "cannot build associated record: #{requested_class} does not inherit from #{klass}"
+        end
       else
-        klass.new(*options)
+        klass.new(*options,&block)
       end
     end
   end

data/lib/patches/rails/translation_helper.rb

@@ -2,7 +2,8 @@
 # of rescuing exceptions itself.
 #
 # See https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/5969-bump-i18n-and-make-translationhelper-use-new-rescue_format-option#ticket-5969-8
-Gem.patching('rails', '3.0.3') do
+# can be removed in 3.1
+Gem.patching('rails', '3.0.9') do
   ActionView::Helpers::TranslationHelper.module_eval do
     def translate(key, options = {})
       options.merge!(:rescue_format => :html) unless options.key?(:rescue_format)

data/lib/patches/responders/flash_responder.rb

@@ -12,6 +12,7 @@ Responders::FlashResponder.class_eval do
     end
 
     defaults << :"flash.#{controller.action_name}.#{status}"
+    defaults << :"flash.actions.#{controller.action_name}.#{status}"
     defaults.uniq << ""
   end
 end

data/lib/patches/simple_form.rb

@@ -2,7 +2,7 @@ require 'gem-patching'
 
 # add "blog edit_blog" as css classes. should propose a patch to simple_form
 
-Gem.patching('simple_form', '1.2.2') do
+Gem.patching('simple_form', '1.3.1') do
   SimpleForm::ActionViewExtensions::FormHelper.module_eval do
     [:form_for, :fields_for, :remote_form_for].each do |helper|
       class_eval <<-METHOD, __FILE__, __LINE__
@@ -34,4 +34,4 @@ Gem.patching('simple_form', '1.2.2') do
       end
     end
   end
-end
+end

data/lib/testing/env.rb

@@ -7,16 +7,8 @@ name = "#{File.basename(Dir.pwd)}-test"
 app = Adva::Generators::App.new(name, :target => '/tmp', :migrate => true)
 app.invoke
 
-Gem.patching('webrat', '0.7.2') do
-  ActionController.send(:remove_const, :AbstractRequest)
-end
-
 require 'cucumber/rails/world'
-require 'cucumber/rails/active_record'
 require 'cucumber/web/tableish'
-require 'webrat'
-require 'webrat/core/matchers'
-require 'patches/webrat/logger'
 require 'test/unit/assertions'
 require 'action_dispatch/testing/assertions'
 require 'factory_girl'
@@ -27,13 +19,27 @@ Adva::Testing.load_cucumber_support
 Adva::Testing.load_assertions
 Adva::Testing.load_helpers
 
-Webrat.configure do |config|
-  config.mode = :rails
-  config.open_error_files = false
+require 'capybara/rails'
+require 'capybara/cucumber'
+Capybara.default_selector = :css
+Capybara.default_wait_time = 5
+World(Capybara)
+
+
+require 'database_cleaner'
+require 'database_cleaner/cucumber'
+DatabaseCleaner.strategy = :transaction
+DatabaseCleaner.clean_with :truncation
+
+# Fix undefined method `add_assertion' for nil:NilClass for all assertions
+# https://github.com/aslakhellesoy/cucumber-rails/issues/97
+if RUBY_VERSION =~ /1.8/
+  require 'test/unit/testresult'
+  Test::Unit.run = true
 end
 
-ActionController::Base.allow_rescue = false
-Cucumber::Rails::World.use_transactional_fixtures = true
+#ActionController::Base.allow_rescue = false
+#Cucumber::Rails::World.use_transactional_fixtures = true
 Rails.backtrace_cleaner.remove_silencers!
 
 World(GlobalHelpers)

data/lib/testing/factories.rb

@@ -1,5 +1,9 @@
+def Factory.the_account
+  Account.first || Account.create!
+end
+
 Factory.define :site do |f|
-  f.account Account.first || Account.create!
+  f.account { Factory.the_account }
   f.name    'adva-cms'
   f.host    'www.example.com'
   f.title   'adva-cms'

data/lib/testing/paths.rb

@@ -27,7 +27,7 @@ module Adva::Core::Paths
       polymorphic_path([:admin, :sites])
 
     when /^the admin dashboard page$/
-      site = Site.first
+      site = Site.first || raise("no site found")
       polymorphic_path([:admin, site])
 
     when /^the admin dashboard page for the site on "([^"]*)"$/
@@ -35,16 +35,16 @@ module Adva::Core::Paths
       polymorphic_path([:admin, site])
 
     when /^the admin sections page$/
-      site = Site.first
+      site = Site.first || raise("no site found")
       polymorphic_path([:admin, site, :sections])
 
     when /^the admin "([^"]*)" section page$/
-      site = Site.first
+      site = Site.first || raise("no site found")
       section = Section.where(:name => $1).first || raise("could not find section named #{$1}")
       polymorphic_path([:admin, site, section])
 
     when /^the admin "([^"]*)" section settings page$/
-      site = Site.first
+      site = Site.first || raise("no site found")
       section = Section.where(:name => $1).first || raise("could not find section named #{$1}")
       polymorphic_path([:edit, :admin, site, section])
 

data/lib/testing/selectors.rb

@@ -0,0 +1,72 @@
+module HtmlSelectorsHelpers
+  # Maps a name to a selector. Used primarily by the
+  #
+  #   When /^(.+) within (.+)$/ do |step, scope|
+  #
+  # step definitions in web_steps.rb
+  #
+  Word = /[a-z_\-]+/
+  def selector_for(locator)
+    case locator
+
+    when /the page/
+      "html > body"
+
+    when /([a-z ]+) form/
+      name = $1.gsub(' ', '_') #.gsub(/edit_/, '')
+      "form.#{name}, form##{name}"
+
+      #  I follow "View" within the "Blog" row
+      #                         ^^^^^^^^^^^^^^
+      #  selects the rows in which the given text shows up
+    when /the "([^"]*)" row/
+      having_text = %Q~contains( text(), "#{$1}")~
+      row = "//table//tr[ descendant::*[#{having_text}] ]"
+      [:xpath, row]
+
+      #  I should see "Categories" within tabs
+      #                                   ^^^^
+    when /^(?:a?n )?(#{Word})$/
+      ".#{$1}"
+
+    when 'the title'
+      "h1,h2,h3"
+
+    when 'the top menu'
+      "#top"
+
+    when 'the main menu'
+      "ul.main.menu"
+
+    when /^the actions? menu$/
+      "#actions"
+
+    when /^the (#{Word})$/
+      "##{$1}"
+
+    # Add more mappings here.
+    # Here is an example that pulls values out of the Regexp:
+    #
+    #  when /the (notice|error|info) flash/
+    #    ".flash.#{$1}"
+    
+    # You can also return an array to use a different selector
+    # type, like:
+    #
+    #  when /the header/
+    #    [:xpath, "//header"]
+
+    # This allows you to provide a quoted selector as the scope
+    # for "within" steps as was previously the default for the
+    # web steps:
+    when /"(.+)"/
+      $1
+
+    else
+      raise "Can't find mapping from \"#{locator}\" to a selector.\n" +
+        "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(HtmlSelectorsHelpers)

data/lib/testing/step_definitions/capybara_steps.rb

@@ -0,0 +1,211 @@
+# TL;DR: YOU SHOULD DELETE THIS FILE
+#
+# This file iwas 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__), "..", "paths"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "selectors"))
+
+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)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^"]*)"$/ do |button|
+  click_button(button)
+end
+
+When /^(?:|I )follow "([^"]*)"$/ do |link|
+  click_link(link)
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"$/ do |value, field|
+  fill_in(field, :with => value)
+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:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    When %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"$/ do |value, field|
+  select(value, :from => field)
+end
+
+When /^(?:|I )check "([^"]*)"$/ do |field|
+  check(field)
+end
+
+When /^(?:|I )uncheck "([^"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^(?:|I )choose "([^"]*)"$/ do |field|
+  choose(field)
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"$/ do |path, field|
+  attach_file(field, File.expand_path(path))
+end
+
+Then /^(?:|I )should see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_content(text)
+  else
+    assert page.has_content?(text)
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  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 page.respond_to? :should
+    page.should have_no_content(text)
+  else
+    assert page.has_no_content?(text)
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_no_xpath('//*', :text => regexp)
+  else
+    assert page.has_no_xpath?('//*', :text => regexp)
+  end
+end
+
+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_match(/#{value}/, field_value)
+    end
+  end
+end
+
+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(?: 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(?: 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
+    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