wagn 1.18.6 → 1.19.0

data/rails/application-routes.rb

@@ -1,6 +1,6 @@
 Wagn.application.routes.draw do
   if !Rails.env.production? && Object.const_defined?(:JasmineRails)
-    mount Object.const_get(:JasmineRails).const_get(:Engine) => '/specs'
+    mount Object.const_get(:JasmineRails).const_get(:Engine) => "/specs"
   end
-  mount Decko::Engine => '/'
+  mount Decko::Engine => "/"
 end

data/rails/controllers/card_controller.rb

@@ -1,14 +1,17 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency 'card'
+require_dependency "card"
 
-require_dependency 'wagn/exceptions'
-require_dependency 'card/mailer'  # otherwise Net::SMTPError rescues can cause
+require_dependency "wagn/exceptions"
+require_dependency "wagn/response"
+require_dependency "card/mailer"  # otherwise Net::SMTPError rescues can cause
 # problems when error raised comes before Card::Mailer is mentioned
 
+# Wagn's only controller.
 class CardController < ActionController::Base
-  include Card::Location
+  include Card::Env::Location
   include Recaptcha::Verify
+  include Wagn::Response
 
   layout nil
   attr_reader :card
@@ -32,13 +35,11 @@ class CardController < ActionController::Base
     handle { card.delete }
   end
 
-  # DEPRECATED
+  # @deprecated
   def asset
-    Rails.logger.info 'Routing assets through Card. Recommend symlink from ' \
+    Rails.logger.info "Routing assets through Card. Recommend symlink from " \
                       'Deck to Card gem using "rake wagn:update_assets_symlink"'
-    asset_path = Decko::Engine.paths['gem-assets'].existent.first
-    filename   = [params[:filename], params[:format]].join('.')
-    send_asset asset_path, filename, x_sendfile: true
+    send_deprecated_asset
   end
 
   # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -52,41 +53,28 @@ class CardController < ActionController::Base
   before_filter :authenticate, except: [:asset]
   before_filter :load_id, only: [:read]
   before_filter :load_card, except: [:asset]
-  before_filter :refresh_card, only: [:create, :update, :delete, :rollback]
+  before_filter :refresh_card, only: [:create, :update, :delete]
 
   def setup
     request.format = :html unless params[:format] # is this used??
+    Card::Mod::Loader.refresh_script_and_style if Rails.env.development?
     Card::Cache.renew
     Card::Env.reset controller: self
   end
 
   def authenticate
-    if params[:token]
-      ok = Card::Auth.set_current_from_token params[:token], params[:current]
-      raise Card::Oops, 'token authentication failed' unless ok
-      # arguably should be PermissionDenied; that requires a card object,
-      # and that's not loaded yet.
-    else
-      Card::Auth.set_current_from_session
-    end
+    Card::Auth.set_current params[:token], params[:current]
   end
 
   def load_id
-    params[:id] =
-      case params[:id]
-      when '*previous' then return card_redirect(Card::Env.previous_location)
-      when nil         then determine_id
-      else                  validate_id_encoding params[:id]
-      end
+    params[:id] = interpret_id params[:id]
   end
 
   def load_card
-    @card = new_or_fetch_card
-    raise Card::NotFound unless @card
-
+    @card = Card.deep_fetch params
+    raise Card::Error::NotFound unless @card
     @card.select_action_by_params params #
-    Card::Env[:main_name] = params[:main] || (card && card.name) || ''
-
+    Card::Env[:main_name] = params[:main] || (card && card.name) || ""
     card.errors.any? ? render_errors : true
   end
 
@@ -96,77 +84,6 @@ class CardController < ActionController::Base
 
   # ----------( HELPER METHODS ) -------------
 
-  def new_or_fetch_card
-    opts = card_opts
-    if params[:action] == 'create'
-      # FIXME: we currently need a "new" card to catch duplicates
-      # (otherwise save will just act like a normal update)
-      # We may need a "#create" instance method to handle this checking?
-      Card.new opts
-    else
-      mark = params[:id] || opts[:name]
-      Card.fetch mark, new: opts
-    end
-  end
-
-  def card_opts
-    opts = (params[:card] || {}).clone
-    # clone so that original params remain unaltered.  need deeper clone?
-    opts[:type] ||= params[:type] if params[:type]
-    # for /new/:type shortcut.  we should fix and deprecate this.
-    opts[:name] ||= params[:id].to_s.tr('_', ' ')
-    # move handling to Card::Name?
-    opts
-  end
-
-  def determine_id
-    case
-    when needs_setup?
-      prepare_setup_card!
-    when params[:card] && params[:card][:name]
-      params[:card][:name]
-    when Card::Format.tagged(params[:view], :unknown_ok)
-      ''
-    else
-      Card.global_setting(:home) || 'Home'
-    end
-  end
-
-  def needs_setup?
-    Card::Auth.needs_setup? && Card::Env.html?
-  end
-
-  def prepare_setup_card!
-    params[:card] = { type_id: Card.default_accounted_type_id }
-    params[:view] = 'setup'
-    ''
-  end
-
-  def validate_id_encoding id
-    # we should find the place where we produce these bad urls
-    id.valid_encoding? ? id : id.force_encoding('ISO-8859-1').encode('UTF-8')
-  end
-
-  def send_asset path, filename, options={}
-    if filename.include? '../'
-      # for security, block relative paths
-      raise Wagn::BadAddress
-    else
-      send_file File.join(path, filename), options
-    end
-  end
-
-  def card_redirect url
-    url = card_url url # make sure we have absolute url
-    if ajax?
-      # lets client reset window location (not just receive redirected response)
-      # formerly used 303 response, but that gave IE the fits
-      render json: { redirect: url }
-    else
-      redirect_to url
-    end
-  end
-
   def handle
     card.act(success: true) do
       yield ? render_success : render_errors
@@ -174,119 +91,43 @@ class CardController < ActionController::Base
   end
 
   def render_success
+    success = Card::Env.success
     success.name_context = @card.cardname
-    return card_redirect success.to_url if !ajax? || success.hard_redirect?
-    return render text: success.target if success.target.is_a? String
-
-    @card = success.target
-    update_params_for_success
-    @card.select_action_by_params params
-    show
-  end
-
-  def render_errors
-    # FIXME: should prioritize certain error classes
-    code = nil
-    card.errors.each do |key, _msg|
-      break if (code = Card.error_codes[key])
+    if !Card::Env.ajax? || success.hard_redirect?
+      card_redirect success.to_url
+    elsif success.target.is_a? String
+      render text: success.target
+    else
+      reset_card success.target
+      show
     end
-    view, status = code || [:errors, 422]
-    show view, status
   end
 
   def show view=nil, status=200
     card.action = :read
     card.content = card.last_draft_content if use_draft?
 
-    view ||= params[:view]
-    slot_opts = (params[:slot] || {}).deep_symbolize_keys
+    formatname = format_from_params
+    format = card.format formatname
 
-    format = format_from_params
-    formatter = card.format(format.to_sym)
-    result = card.act { formatter.page view, slot_opts }
-    status = formatter.error_status || status
+    view ||= params[:view]
+    result = card.act do
+      format.page view, page_opts_from_params
+    end
 
-    deliver format, result, status
+    status = format.error_status || status
+    deliver formatname, result, status
   end
 
-  def deliver format, result, status
-    if format == :file && status == 200
-      send_file(*result)
-    elsif status == 302
-      card_redirect result
-    else
-      args = { text: result, status: status }
-      args[:content_type] = 'text/text' if format == :file
-      render args
-    end
+  def render_errors
+    view, status = Card::Error.view_and_status(card) || [:errors, 422]
+    show view, status
   end
 
   rescue_from StandardError do |exception|
     Rails.logger.info "exception = #{exception.class}: #{exception.message}"
-
     @card ||= Card.new
     Card::Error.current = exception
-    view =
-
-      case exception
-      ## arguably the view and status should be defined in the error class;
-      ## some are redundantly defined in view
-      when Card::Oops, Card::BadQuery
-        card.errors.add :exception, exception.message
-        # these error messages are visible to end users and are generally not
-        # treated as bugs.
-        # Probably want to rename accordingly.
-        :errors
-      when Card::PermissionDenied
-        :denial
-      when Card::NotFound, ActiveRecord::RecordNotFound,
-           ActionController::MissingFile
-        :not_found
-      when Wagn::BadAddress
-        :bad_address
-      else
-        # the following indicate a code problem and therefore require full
-        # logging
-        @card.notable_exception_raised
-
-        if ActiveRecord::RecordInvalid === exception
-          :errors
-        # could also just check non-production mode...
-        elsif Rails.logger.level == 0
-          raise exception
-        else
-          :server_error
-        end
-      end
-
-    show view
-  end
-
-  def ajax?
-    Card::Env.ajax?
-  end
-
-  def success
-    Card::Env[:success]
-  end
-
-  def format_from_params
-    return :file if params[:explicit_file]
-    format = request.parameters[:format]
-    return :file unless Card::Format.registered.member?(format) # unknown format
-    format
-  end
-
-  def update_params_for_success
-    if success.soft_redirect?
-      self.params = success.params
-    else
-      # need tests. insure we get slot, main...
-      params.merge! success.params
-    end
-  end
-
-  def use_draft?
-    params[:edit_draft] && card.drafts.present?
+    show Card::Error.exception_view(@card, exception)
   end
 end

data/rails/engine-routes.rb

@@ -2,49 +2,49 @@
 
 Decko::Engine.routes.draw do
   # most common
-  root 'card#read'
+  root "card#read"
   get "#{Decko::Engine.config.files_web_path}/:id/:rev_id(-:size).:format" =>
-                                 'card#read', id: /[^-]+/, rev_id: /[^-]+/, explicit_file: true
+                                 "card#read", id: /[^-]+/, rev_id: /[^-]+/, explicit_file: true
   get "#{Decko::Engine.config.files_web_path}/:id(-:size)-:rev_id.:format" =>
-                                 'card#read', id: /[^-]+/, explicit_file: true  # deprecated
-  get 'assets/*filename'      => 'card#asset'
-  get 'javascripts/*filename' => 'card#asset'
-  get 'jasmine/*filename'     => 'card#asset'
+                                 "card#read", id: /[^-]+/, explicit_file: true  # deprecated
+  get "assets/*filename"      => "card#asset"
+  get "javascripts/*filename" => "card#asset"
+  get "jasmine/*filename"     => "card#asset"
 
-  get 'recent(.:format)'      => 'card#read', id: ':recent' # obviate by making links use codename
+  get "recent(.:format)"      => "card#read", id: ":recent" # obviate by making links use codename
   #  match ':view:(:id(.:format))'          => 'card#read', via: :get
-  get '(/wagn)/:id(.:format)' => 'card#read'  # /wagn is deprecated
+  get "(/wagn)/:id(.:format)" => "card#read"  # /wagn is deprecated
 
   # RESTful
-  post   '/' => 'card#create'
-  put    '/' => 'card#update'
-  delete '/' => 'card#delete'
+  post   "/" => "card#create"
+  put    "/" => "card#update"
+  delete "/" => "card#delete"
 
-  match ':id(.:format)' => 'card#create', via: :post
-  match ':id(.:format)' => 'card#update', via: :put
-  match ':id(.:format)' => 'card#delete', via: :delete
+  match ":id(.:format)" => "card#create", via: :post
+  match ":id(.:format)" => "card#update", via: :put
+  match ":id(.:format)" => "card#delete", via: :delete
 
   # ~~~~~~~~~~~~~~~~~~~~~~~~~~
   # legacy
-  get 'new/:type'                  => 'card#read',   view: 'new'
-  get 'card/:view(/:id(.:format))' => 'card#read',   view: /new|options|edit/
-
-  get 'account/signin'             => 'card#read',   id: ':signin'
-  get 'account/signout'            => 'card#delete', id: ':signin'
-  get 'account/signup'             => 'card#read',   view: 'new',  card: { type_code: :signup }
-  get 'account/invite'             => 'card#read',   view: 'new',  card: { type_code: :signup }
-  get 'account/accept'             => 'card#read',   view: 'edit', card: { type_code: :signup }
+  get "new/:type"                  => "card#read",   view: "new"
+  get "card/:view(/:id(.:format))" => "card#read",   view: /new|options|edit/
+
+  get "account/signin"             => "card#read",   id: ":signin"
+  get "account/signout"            => "card#delete", id: ":signin"
+  get "account/signup"             => "card#read",   view: "new",  card: { type_code: :signup }
+  get "account/invite"             => "card#read",   view: "new",  card: { type_code: :signup }
+  get "account/accept"             => "card#read",   view: "edit", card: { type_code: :signup }
   # use type_code rather than id because in some cases (eg populating test data) routes must get loaded without loading Card
 
-  get 'admin/stats'                => 'card#read',   id: ':stats'
-  get 'admin/:task'                => 'card#update', id: ':all'
+  get "admin/stats"                => "card#read",   id: ":stats"
+  get "admin/:task"                => "card#update", id: ":all"
   # ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
   # standard non-RESTful
-  get '(card)/:action(/:id(.:format))'  => 'card', action: /create|read|update|delete|asset/
-  match '(card)/create(/:id(.:format))' => 'card#create', via: [:post, :patch]
-  match '(card)/update(/:id(.:format))' => 'card#update', via: [:post, :put, :patch]
-  match '(card)/delete(/:id(.:format))' => 'card#delete', via: :delete
+  get "(card)/:action(/:id(.:format))"  => "card", action: /create|read|update|delete|asset/
+  match "(card)/create(/:id(.:format))" => "card#create", via: [:post, :patch]
+  match "(card)/update(/:id(.:format))" => "card#update", via: [:post, :put, :patch]
+  match "(card)/delete(/:id(.:format))" => "card#delete", via: :delete
   # other
-  get '*id' => 'card#read', view: 'bad_address'
+  get "*id" => "card#read", view: "bad_address"
 end

data/script/autospec

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-ENV['RSPEC'] = 'true'     # allows autotest to discover rspec
-ENV['AUTOTEST'] = 'true'  # allows autotest to run w/ color on linux
-system (RUBY_PLATFORM =~ /mswin|mingw/ ? 'autotest.bat' : 'autotest'), *ARGV
+ENV["RSPEC"] = "true"     # allows autotest to discover rspec
+ENV["AUTOTEST"] = "true"  # allows autotest to run w/ color on linux
+system (RUBY_PLATFORM =~ /mswin|mingw/ ? "autotest.bat" : "autotest"), *ARGV

data/script/rails

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
 
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
-require 'rails/commands'
+APP_PATH = File.expand_path("../../config/application",  __FILE__)
+require File.expand_path("../../config/boot",  __FILE__)
+require "rails/commands"

data/script/test_filter

@@ -1,8 +1,8 @@
 #!/usr/local/bin/ruby
 
 STDOUT.sync = true
-errors_filename = './log/err.out'
-err_out = File.new(errors_filename, 'a')
+errors_filename = "./log/err.out"
+err_out = File.new(errors_filename, "a")
 
 ARGF.each_line do |l|
   error_section = false

data/script/wagn

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
 
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
-require 'wagn/commands'
+APP_PATH = File.expand_path("../../config/application",  __FILE__)
+require File.expand_path("../../config/boot",  __FILE__)
+require "wagn/commands"

data/spec/controllers/card_controller_spec.rb

@@ -4,359 +4,383 @@ describe CardController do
   routes { Decko::Engine.routes }
 
   include Capybara::DSL
-  describe '- route generation' do
-    it 'should recognize type' do
+  describe "- route generation" do
+    def card_route_to opts={}
+      route_to opts.merge(controller: "card")
+    end
+
+    it "should recognize type" do
       # all_routes = Rails.application.routes.routes
       # require 'rails/application/route_inspector'
       # warn "rountes#{ENV['CONTROLLER']}:\n" + Rails::Application::RouteInspector.new.format(all_routes, ENV['CONTROLLER'])* "\n"
 
-      expect(get: '/new/Phrase').to route_to(controller: 'card', action: 'read', type: 'Phrase', view: 'new')
+      expect(get: "/new/Phrase")
+        .to card_route_to(action: "read", type: "Phrase", view: "new")
     end
 
-    it 'should recognize .rss on /recent' do
-      expect(get: '/recent.rss').to route_to(controller: 'card', action: 'read', id: ':recent', format: 'rss')
+    it "should recognize .rss on /recent" do
+      expect(get: "/recent.rss")
+        .to card_route_to(action: "read", id: ":recent", format: "rss")
     end
 
-    it 'should handle RESTful posts' do
-      expect(put: '/mycard').to route_to(controller: 'card', action: 'update', id: 'mycard')
-      expect(put: '/').to route_to(controller: 'card', action: 'update')
+    it "should handle RESTful posts" do
+      expect(put: "/mycard").to card_route_to(action: "update", id: "mycard")
+      expect(put: "/").to card_route_to(action: "update")
     end
 
-    it 'handle asset requests' do
-      expect(get: '/asset/application.js').to route_to(controller: 'card', action: 'asset', id: 'application', format: 'js')
+    it "handle asset requests" do
+      expect(get: "/asset/application.js")
+        .to card_route_to(action: "asset", id: "application", format: "js")
     end
 
-    ['/wagn', ''].each do |prefix|
+    ["/wagn", ""].each do |prefix|
       describe "routes prefixed with '#{prefix}'" do
-        it 'should recognize .rss format' do
-          expect(get: "#{prefix}/*recent.rss").to route_to(
-            controller: 'card', action: 'read', id: '*recent', format: 'rss'
-          )
+        it "should recognize .rss format" do
+          expect(get: "#{prefix}/*recent.rss")
+            .to card_route_to(action: "read", id: "*recent", format: "rss")
         end
 
-        it 'should recognize .xml format' do
-          expect(get: "#{prefix}/*recent.xml").to route_to(
-            controller: 'card', action: 'read', id: '*recent', format: 'xml'
-          )
+        it "should recognize .xml format" do
+          expect(get: "#{prefix}/*recent.xml")
+            .to card_route_to(action: "read", id: "*recent", format: "xml")
         end
 
-        it 'should accept cards without dots' do
-          expect(get: "#{prefix}/random").to route_to(
-            controller: 'card', action: 'read', id: 'random'
-          )
+        it "should accept cards without dots" do
+          expect(get: "#{prefix}/random")
+            .to card_route_to(action: "read", id: "random")
         end
       end
     end
   end
 
-  describe '#create' do
+  describe "#create" do
     before do
-      login_as 'joe_user'
+      login_as "joe_user"
     end
 
     # FIXME: several of these tests go all the way to DB,
     #  which means they're closer to integration than unit tests.
     #  maybe think about refactoring to use mocks etc. to reduce
     #  test dependencies.
-    it 'creates cards' do
+    it "creates cards" do
       post :create, card: {
-        name: 'NewCardFoo',
-        type: 'Basic',
-        content: 'Bananas'
+        name: "NewCardFoo",
+        type: "Basic",
+        content: "Bananas"
       }
       assert_response 302
-      c = Card['NewCardFoo']
+      c = Card["NewCardFoo"]
       expect(c.type_code).to eq(:basic)
-      expect(c.content).to eq('Bananas')
+      expect(c.content).to eq("Bananas")
     end
 
-    it 'handles permission denials' do
+    it "handles permission denials" do
       post :create, card: {
-        name: 'LackPerms',
-        type: 'Html'
+        name: "LackPerms",
+        type: "Html"
       }
       assert_response 403
-      expect(Card['LackPerms']).to be_nil
+      expect(Card["LackPerms"]).to be_nil
     end
 
     # no controller-specific handling.  move test elsewhere
-    it 'creates cardtype cards' do
-      xhr :post, :create, card: { 'content' => 'test', type: 'Cardtype', name: 'Editor' }
-      expect(assigns['card']).not_to be_nil
+    it "creates cardtype cards" do
+      xhr :post, :create,
+          card: { "content" => "test", type: "Cardtype", name: "Editor" }
+      expect(assigns["card"]).not_to be_nil
       assert_response 200
-      c = Card['Editor']
+      c = Card["Editor"]
       expect(c.type_code).to eq(:cardtype)
     end
 
     # no controller-specific handling.  move test elsewhere
-    it 'pulls deleted cards from trash' do
-      @c = Card.create! name: 'Problem', content: 'boof'
+    it "pulls deleted cards from trash" do
+      @c = Card.create! name: "Problem", content: "boof"
       @c.delete!
-      post :create, card: { 'name' => 'Problem', 'type' => 'Phrase', 'content' => 'noof' }
+      post :create,
+           card: {
+             "name" => "Problem", "type" => "Phrase", "content" => "noof"
+           }
       assert_response 302
-      c = Card['Problem']
+      c = Card["Problem"]
       expect(c.type_code).to eq(:phrase)
     end
 
-    context 'multi-create' do
-      it 'catches missing name error' do
-        post :create, 'card' => {
-          'name' => '',
-          'type' => 'Fruit',
-          'subcards' => { '+text' => { 'content' => '<p>abraid</p>' } }
-        }, 'view' => 'open'
+    context "multi-create" do
+      it "catches missing name error" do
+        post :create, "card" => {
+          "name" => "",
+          "type" => "Fruit",
+          "subcards" => { "+text" => { "content" => "<p>abraid</p>" } }
+        }, "view" => "open"
         assert_response 422
-        expect(assigns['card'].errors[:name].first).to eq("can't be blank")
+        expect(assigns["card"].errors[:name].first).to eq("can't be blank")
       end
 
-      it 'creates card with subcards' do
-        login_as 'joe_admin'
-        xhr :post, :create, success: 'REDIRECT: /', card: {
-          name: 'Gala',
-          type: 'Fruit',
+      it "creates card with subcards" do
+        login_as "joe_admin"
+        xhr :post, :create, success: "REDIRECT: /", card: {
+          name: "Gala",
+          type: "Fruit",
           subcards: {
-            '+kind'  => { content: 'apple' },
-            '+color' => { type: 'Phrase', content: 'red'  }
+            "+kind"  => { content: "apple" },
+            "+color" => { type: "Phrase", content: "red"  }
           }
         }
         assert_response 200
-        expect(Card['Gala']).not_to be_nil
-        expect(Card['Gala+kind'].content).to eq('apple')
-        expect(Card['Gala+color'].type_name).to eq('Phrase')
+        expect(Card["Gala"]).not_to be_nil
+        expect(Card["Gala+kind"].content).to eq("apple")
+        expect(Card["Gala+color"].type_name).to eq("Phrase")
       end
     end
 
-    it 'renders errors if create fails' do
-      post :create, 'card' => { 'name' => 'Joe User' }
+    it "renders errors if create fails" do
+      post :create, "card" => { "name" => "Joe User" }
       assert_response 422
     end
 
-    it 'redirects to thanks if present' do
-      login_as 'joe_admin'
-      xhr :post, :create, success: 'REDIRECT: /thank_you', card: { 'name' => 'Wombly' }
+    it "redirects to thanks if present" do
+      login_as "joe_admin"
+      xhr :post, :create, success: "REDIRECT: /thank_you",
+                          card: { "name" => "Wombly" }
       assert_response 200
       json = JSON.parse response.body
-      expect(json['redirect']).to match(/^http.*\/thank_you$/)
+      expect(json["redirect"]).to match(/^http.*\/thank_you$/)
     end
 
-    it 'redirects to card if thanks is blank' do
-      login_as 'joe_admin'
-      post :create, success: 'REDIRECT: _self', 'card' => { 'name' => 'Joe+boop' }
-      assert_redirected_to '/Joe+boop'
+    it "redirects to card if thanks is blank" do
+      login_as "joe_admin"
+      post :create, success: "REDIRECT: _self",
+                    "card" => { "name" => "Joe+boop" }
+      assert_redirected_to "/Joe+boop"
     end
 
-    it 'redirects to previous' do
+    it "redirects to previous" do
       # Fruits (from shared_data) are anon creatable but not readable
       login_as :anonymous
-      post :create, { success: 'REDIRECT: *previous', 'card' => { 'type' => 'Fruit', name: 'papaya' } }, history: ['/blam']
-      assert_redirected_to '/blam'
+      post :create, { success: "REDIRECT: *previous",
+                      "card" => { "type" => "Fruit", name: "papaya" } },
+           history: ["/blam"]
+      assert_redirected_to "/blam"
     end
   end
 
-  describe '#read' do
-    it 'works for basic request' do
-      get :read, id: 'Sample_Basic'
+  describe "#read" do
+    it "works for basic request" do
+      get :read, id: "Sample_Basic"
       expect(response.body.match(/\<body[^>]*\>/im)).to be_truthy
-      # have_selector broke in commit 8d3bf2380eb8197410e962304c5e640fced684b9, presumably because of a gem (like capybara?)
+      # have_selector broke in commit 8d3bf2380eb8197410e962304c5e640fced684b9,
+      # presumably because of a gem (like capybara?)
       # response.should have_selector('body')
       assert_response :success
-      expect('Sample Basic').to eq(assigns['card'].name)
+      expect("Sample Basic").to eq(assigns["card"].name)
     end
 
-    it 'handles nonexistent card with create permission' do
-      login_as 'joe_user'
-      get :read, id: 'Sample_Fako'
+    it "handles nonexistent card with create permission" do
+      login_as "joe_user"
+      get :read, id: "Sample_Fako"
       assert_response :success
     end
 
-    it 'handles nonexistent card without create permissions' do
-      get :read, id: 'Sample_Fako'
+    it "handles nonexistent card without create permissions" do
+      get :read, id: "Sample_Fako"
       assert_response 404
     end
 
-    it 'handles nonexistent card ids' do
-      get :read, id: '~9999999'
+    it "handles nonexistent card ids" do
+      get :read, id: "~9999999"
       assert_response 404
     end
 
-    it 'returns denial when no read permission' do
+    it "returns denial when no read permission" do
       Card::Auth.as_bot do
-        Card.create! name: 'Strawberry', type: 'Fruit' # only admin can read
+        Card.create! name: "Strawberry", type: "Fruit" # only admin can read
       end
-      get :read, id: 'Strawberry'
+      get :read, id: "Strawberry"
       assert_response 403
-      get :read, id: 'Strawberry', format: 'txt'
+      get :read, id: "Strawberry", format: "txt"
       assert_response 403
     end
 
-    context 'view = new' do
+    context "view = new" do
       before do
-        login_as 'joe_user'
+        login_as "joe_user"
       end
 
-      it 'should work on index' do
-        get :read, view: 'new'
-        expect(assigns['card'].name).to eq('')
-        assert_response :success, 'response should succeed'
-        assert_equal Card::BasicID, assigns['card'].type_id, '@card type should == Basic'
+      it "should work on index" do
+        get :read, view: "new"
+        expect(assigns["card"].name).to eq("")
+        assert_response :success, "response should succeed"
+        assert_equal Card::BasicID, assigns["card"].type_id,
+                     "@card type should == Basic"
       end
 
-      it 'new with name' do
-        post :read, card: { name: 'BananaBread' }, view: 'new'
-        assert_response :success, 'response should succeed'
-        assert_equal 'BananaBread', assigns['card'].name, '@card.name should == BananaBread'
+      it "new with name" do
+        post :read, card: { name: "BananaBread" }, view: "new"
+        assert_response :success, "response should succeed"
+        assert_equal "BananaBread", assigns["card"].name,
+                     "@card.name should == BananaBread"
       end
 
-      it 'new with existing name' do
-        get :read, card: { name: 'A' }, view: 'new'
-        assert_response :success, 'response should succeed'  # really?? how come this is ok?
+      it "new with existing name" do
+        get :read, card: { name: "A" }, view: "new"
+        # really?? how come this is ok?
+        assert_response :success, "response should succeed"
       end
 
-      it 'new with type_code' do
-        post :read, card: { type: 'Date' }, view: 'new'
-        assert_response :success, 'response should succeed'
-        assert_equal Card::DateID, assigns['card'].type_id, '@card type should == Date'
+      it "new with type_code" do
+        post :read, card: { type: "Date" }, view: "new"
+        assert_response :success, "response should succeed"
+        assert_equal Card::DateID, assigns["card"].type_id,
+                     "@card type should == Date"
       end
 
-      it 'new should work for creatable nonviewable cardtype' do
+      it "new should work for creatable nonviewable cardtype" do
         login_as :anonymous
-        get :read, type: 'Fruit', view: 'new'
+        get :read, type: "Fruit", view: "new"
         assert_response :success
       end
 
-      it 'should use card params name over id in new cards' do
-        get :read, id: 'my_life', card: { name: 'My LIFE' }, view: 'new'
-        expect(assigns['card'].name).to eq('My LIFE')
+      it "should use card params name over id in new cards" do
+        get :read, id: "my_life", card: { name: "My LIFE" }, view: "new"
+        expect(assigns["card"].name).to eq("My LIFE")
       end
     end
 
-    context 'css' do
+    context "css" do
       before do
         @all_style = Card["#{Card[:all].name}+#{Card[:style].name}"]
-        @all_style.reset_machine_output!
+        @all_style.reset_machine_output
       end
 
-      it 'creates missing machine output file' do
-        args = { id: @all_style.machine_output_card.name, format: 'css', explicit_file: true }
+      it "creates missing machine output file" do
+        args = { id: @all_style.machine_output_card.name,
+                 format: "css",
+                 explicit_file: true }
         get :read, args
-        output_card = Card["#{Card[:all].name}+#{Card[:style].name}+#{Card[:machine_output].name}"]
+        # output_card = Card[:all, :style, :machine_output]
         expect(response).to redirect_to(@all_style.machine_output_url)
         get :read, args
         expect(response.status).to eq(200)
       end
     end
 
-    context 'file' do
+    context "file" do
       before do
         Card::Auth.as_bot do
-          Card.create name: 'mao2', type_code: 'image', image: File.new(File.join FIXTURES_PATH, 'mao2.jpg')
-          Card.create name: 'mao2+*self+*read', content: '[[Administrator]]'
+          Card.create name: "mao2", type_code: "image",
+                      image: File.new(File.join(FIXTURES_PATH, "mao2.jpg"))
+          Card.create name: "mao2+*self+*read", content: "[[Administrator]]"
         end
       end
 
-      it 'handles image with no read permission' do
-        get :read, id: 'mao2'
-        assert_response 403, 'should deny html card view'
-        get :read, id: 'mao2', format: 'jpg'
-        assert_response 403, 'should deny simple file view'
+      it "handles image with no read permission" do
+        get :read, id: "mao2"
+        assert_response 403, "should deny html card view"
+        get :read, id: "mao2", format: "jpg"
+        assert_response 403, "should deny simple file view"
       end
 
-      it 'handles image with read permission' do
-        login_as 'joe_admin'
-        get :read, id: 'mao2'
+      it "handles image with read permission" do
+        login_as "joe_admin"
+        get :read, id: "mao2"
         assert_response 200
-        get :read, id: 'mao2', format: 'jpg'
+        get :read, id: "mao2", format: "jpg"
         assert_response 200
       end
     end
   end
 
-  describe '#asset' do
-    it 'serves file' do
-      filename = 'asset-test.txt'
-      args = { id: filename, format: 'txt', explicit_file: true }
-      path = File.join(Decko::Engine.paths['gem-assets'].existent.first, filename)
-      File.open(path, 'w') { |f| f.puts 'test' }
+  describe "#asset" do
+    it "serves file" do
+      filename = "asset-test.txt"
+      args = { id: filename, format: "txt", explicit_file: true }
+      path =
+        File.join(Decko::Engine.paths["gem-assets"].existent.first, filename)
+      File.open(path, "w") { |f| f.puts "test" }
       args = { filename: filename.to_s }
       visit "/assets/#{filename}"
       expect(page.body).to eq "test\n"
       FileUtils.rm path
     end
 
-    it 'denies access to other directories' do
-      args = { filename: '/../../Gemfile' }
+    it "denies access to other directories" do
+      args = { filename: "/../../Gemfile" }
       get :asset, args
       expect(response.status).to eq(404)
     end
   end
 
-  describe 'unit tests' do
+  describe "unit tests" do
     before do
-      @simple_card = Card['Sample Basic']
-      login_as 'joe_user'
+      @simple_card = Card["Sample Basic"]
+      login_as "joe_user"
     end
 
-    describe '#update' do
-      it 'works' do
+    describe "#update" do
+      it "works" do
         xhr :post, :update, id: "~#{@simple_card.id}",
-                            card: { content: 'brand new content' }
-        assert_response :success, 'edited card'
-        assert_equal 'brand new content', Card['Sample Basic'].content, 'content was updated'
+                            card: { content: "brand new content" }
+        assert_response :success, "edited card"
+        assert_equal "brand new content", Card["Sample Basic"].content,
+                     "content was updated"
       end
 
-      it 'rename without update references should work' do
-        f = Card.create! type: 'Cardtype', name: 'Apple'
+      it "rename without update references should work" do
+        f = Card.create! type: "Cardtype", name: "Apple"
         xhr :post, :update, id: "~#{f.id}", card: {
-          name: 'Newt',
-          update_referers: 'false'
+          name: "Newt",
+          update_referers: "false"
         }
-        expect(assigns['card'].errors.empty?).not_to be_nil
+        expect(assigns["card"].errors.empty?).not_to be_nil
         assert_response :success
-        expect(Card['Newt']).not_to be_nil
+        expect(Card["Newt"]).not_to be_nil
       end
 
-      it 'update type_code' do
-        xhr :post, :update, id: "~#{@simple_card.id}", card: { type: 'Date' }
-        assert_response :success, 'changed card type'
-        expect(Card['Sample Basic'].type_code).to eq(:date)
+      it "update type_code" do
+        xhr :post, :update, id: "~#{@simple_card.id}", card: { type: "Date" }
+        assert_response :success, "changed card type"
+        expect(Card["Sample Basic"].type_code).to eq(:date)
       end
     end
 
-    describe 'delete' do
-      it 'works' do
-        c = Card.create(name: 'Boo', content: 'booya')
+    describe "delete" do
+      it "works" do
+        c = Card.create(name: "Boo", content: "booya")
         post :delete, id: "~#{c.id}"
         assert_response :redirect
-        expect(Card['Boo']).to eq(nil)
+        expect(Card["Boo"]).to eq(nil)
       end
 
       # FIXME: this should probably be files in the spot for a delete test
-      it 'returns to previous undeleted card after deletion' do
+      it "returns to previous undeleted card after deletion" do
         t1 = t2 = nil
         Card::Auth.as_bot do
-          t1 = Card.create! name: 'Testable1', content: 'hello'
-          t2 = Card.create! name: 'Testable1+bandana', content: 'world'
+          t1 = Card.create! name: "Testable1", content: "hello"
+          t2 = Card.create! name: "Testable1+bandana", content: "world"
         end
 
         get :read, id: t1.key
         get :read, id: t2.key
 
-        post :delete, id: '~' + t2.id.to_s
+        post :delete, id: "~" + t2.id.to_s
         assert_nil Card[t2.name]
         assert_redirected_to "/#{t1.name}"
 
-        post :delete, id: '~' + t1.id.to_s
-        assert_redirected_to '/'
+        post :delete, id: "~" + t1.id.to_s
+        assert_redirected_to "/"
         assert_nil Card[t1.name]
       end
     end
 
-    it 'should comment' do
+    it "should comment" do
       Card::Auth.as_bot do
-        Card.create name: 'basicname+*self+*comment', content: '[[Anyone Signed In]]'
+        Card.create name: "basicname+*self+*comment",
+                    content: "[[Anyone Signed In]]"
       end
-      post :update, id: 'basicname', card: { comment: " and more\n  \nsome lines\n\n" }
-      cont = Card['basicname'].content
+      post :update, id: "basicname",
+                    card: { comment: " and more\n  \nsome lines\n\n" }
+      cont = Card["basicname"].content
       expect(cont).to match(/basiccontent/)
       expect(cont).to match(/some lines/)
     end