lockbox_middleware 1.2.1 → 1.2.2

data/vendor/gems/shoulda-2.10.2/lib/shoulda/macros.rb

@@ -1,133 +0,0 @@
-require 'shoulda/private_helpers'
-
-module Shoulda # :nodoc:
-  module Macros
-    # Macro that creates a test asserting a change between the return value
-    # of a block that is run before and after the current setup block
-    # is run. This is similar to Active Support's <tt>assert_difference</tt>
-    # assertion, but supports more than just numeric values.  See also
-    # should_not_change.
-    #
-    # The passed description will be used when generating the test name and failure messages.
-    #
-    # Example:
-    #
-    #   context "Creating a post" do
-    #     setup { Post.create }
-    #     should_change("the number of posts", :by => 1) { Post.count }
-    #   end
-    #
-    # As shown in this example, the <tt>:by</tt> option expects a numeric
-    # difference between the before and after values of the expression.  You
-    # may also specify <tt>:from</tt> and <tt>:to</tt> options:
-    #
-    #   should_change("the number of posts", :from => 0, :to => 1) { Post.count }
-    #   should_change("the post title", :from => "old", :to => "new") { @post.title }
-    #
-    # Combinations of <tt>:by</tt>, <tt>:from</tt>, and <tt>:to</tt> are allowed:
-    #
-    #   # Assert the value changed in some way:
-    #   should_change("the post title") { @post.title }
-    #
-    #   # Assert the value changed to anything other than "old:"
-    #   should_change("the post title", :from => "old") { @post.title }
-    #
-    #   # Assert the value changed to "new:"
-    #   should_change("the post title", :to => "new") { @post.title }
-    def should_change(description, options = {}, &block)
-      by, from, to = get_options!([options], :by, :from, :to)
-      stmt = "change #{description}"
-      stmt << " from #{from.inspect}" if from
-      stmt << " to #{to.inspect}" if to
-      stmt << " by #{by.inspect}" if by
-
-      if block_given?
-        code = block
-      else
-        warn "[DEPRECATION] should_change(expression, options) is deprecated. " <<
-             "Use should_change(description, options) { code } instead."
-        code = lambda { eval(description) }
-      end
-      before = lambda { @_before_should_change = code.bind(self).call }
-      should stmt, :before => before do
-        old_value = @_before_should_change
-        new_value = code.bind(self).call
-        assert_operator from, :===, old_value, "#{description} did not originally match #{from.inspect}" if from
-        assert_not_equal old_value, new_value, "#{description} did not change" unless by == 0
-        assert_operator to, :===, new_value, "#{description} was not changed to match #{to.inspect}" if to
-        assert_equal old_value + by, new_value if by
-      end
-    end
-
-    # Macro that creates a test asserting no change between the return value
-    # of a block that is run before and after the current setup block
-    # is run. This is the logical opposite of should_change.
-    #
-    # The passed description will be used when generating the test name and failure message.
-    #
-    # Example:
-    #
-    #   context "Updating a post" do
-    #     setup { @post.update_attributes(:title => "new") }
-    #     should_not_change("the number of posts") { Post.count }
-    #   end
-    def should_not_change(description, &block)
-      if block_given?
-        code = block
-      else
-        warn "[DEPRECATION] should_not_change(expression) is deprecated. " <<
-             "Use should_not_change(description) { code } instead."
-        code = lambda { eval(description) }
-      end
-      before = lambda { @_before_should_not_change = code.bind(self).call }
-      should "not change #{description}", :before => before do
-        new_value = code.bind(self).call
-        assert_equal @_before_should_not_change, new_value, "#{description} changed"
-      end
-    end
-
-    # Macro that creates a test asserting that a record of the given class was
-    # created.
-    #
-    # Example:
-    #
-    #   context "creating a post" do
-    #     setup { Post.create(post_attributes) }
-    #     should_create :post
-    #   end
-    def should_create(class_name)
-      should_change_record_count_of(class_name, 1, 'create')
-    end
-
-    # Macro that creates a test asserting that a record of the given class was
-    # destroyed.
-    #
-    # Example:
-    #
-    #   context "destroying a post" do
-    #     setup { Post.first.destroy }
-    #     should_destroy :post
-    #   end
-    def should_destroy(class_name)
-      should_change_record_count_of(class_name, -1, 'destroy')
-    end
-
-    private
-
-    def should_change_record_count_of(class_name, amount, action) # :nodoc:
-      klass = class_name.to_s.camelize.constantize
-      before = lambda do
-        @_before_change_record_count = klass.count
-      end
-      human_name = class_name.to_s.humanize.downcase
-      should "#{action} a #{human_name}", :before => before do
-        assert_equal @_before_change_record_count + amount,
-                     klass.count,
-                     "Expected to #{action} a #{human_name}"
-      end
-    end
-
-    include Shoulda::Private
-  end
-end
-

data/vendor/gems/shoulda-2.10.2/lib/shoulda/private_helpers.rb

@@ -1,13 +0,0 @@
-module Shoulda # :nodoc:
-  module Private # :nodoc:
-    # Returns the values for the entries in the args hash who's keys are listed in the wanted array.
-    # Will raise if there are keys in the args hash that aren't listed.
-    def get_options!(args, *wanted)
-      ret  = []
-      opts = (args.last.is_a?(Hash) ? args.pop : {})
-      wanted.each {|w| ret << opts.delete(w)}
-      raise ArgumentError, "Unsupported options given: #{opts.keys.join(', ')}" unless opts.keys.empty?
-      return wanted.size == 1 ? ret.first : ret
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/proc_extensions.rb

@@ -1,14 +0,0 @@
-# Stolen straight from ActiveSupport
-
-class Proc #:nodoc:
-  def bind(object)
-    block, time = self, Time.now
-    (class << object; self end).class_eval do
-      method_name = "__bind_#{time.to_i}_#{time.usec}"
-      define_method(method_name, &block)
-      method = instance_method(method_name)
-      remove_method(method_name)
-      method
-    end.bind(object)
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/rails.rb

@@ -1,13 +0,0 @@
-require 'rubygems'
-require 'active_support'
-require 'shoulda'
-
-require 'shoulda/active_record'     if defined? ActiveRecord::Base
-require 'shoulda/action_controller' if defined? ActionController::Base
-require 'shoulda/action_view'       if defined? ActionView::Base
-require 'shoulda/action_mailer'     if defined? ActionMailer::Base
-
-if defined?(RAILS_ROOT)
-  # load in the 3rd party macros from vendorized plugins and gems
-  Shoulda.autoload_macros RAILS_ROOT, File.join("vendor", "{plugins,gems}", "*")
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/rspec.rb

@@ -1,11 +0,0 @@
-require 'shoulda/active_record/matchers'
-require 'shoulda/action_controller/matchers'
-require 'active_support/test_case'
-
-# :enddoc:
-module ActiveSupport
-  class TestCase
-    include Shoulda::ActiveRecord::Matchers
-    include Shoulda::ActionController::Matchers
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/tasks/list_tests.rake

@@ -1,29 +0,0 @@
-namespace :shoulda do
-  desc "List the names of the test methods in a specification like format"
-  task :list do
-    $LOAD_PATH.unshift("test")
-
-    require 'test/unit'
-    require 'rubygems'
-    require 'active_support'
-
-    # bug in test unit.  Set to true to stop from running.
-    Test::Unit.run = true
-
-    test_files = Dir.glob(File.join('test', '**', '*_test.rb'))
-    test_files.each do |file|
-      load file
-      klass = File.basename(file, '.rb').classify
-      unless Object.const_defined?(klass.to_s)
-        puts "Skipping #{klass} because it doesn't map to a Class"
-        next
-      end
-      klass = klass.constantize
-
-      puts klass.name.gsub('Test', '')
-
-      test_methods = klass.instance_methods.grep(/^test/).map {|s| s.gsub(/^test: /, '')}.sort
-      test_methods.each {|m| puts "  " + m }
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/tasks/yaml_to_shoulda.rake

@@ -1,28 +0,0 @@
-namespace :shoulda do
-  # From http://blog.internautdesign.com/2007/11/2/a-yaml_to_shoulda-rake-task
-  # David.Lowenfels@gmail.com
-  desc "Converts a YAML file (FILE=./path/to/yaml) into a Shoulda skeleton" 
-  task :from_yaml do
-    require 'yaml'
-    
-    def yaml_to_context(hash, indent = 0)
-      indent1 = '  ' * indent
-      indent2 = '  ' * (indent + 1)
-      hash.each_pair do |context, shoulds|
-        puts indent1 + "context \"#{context}\" do" 
-        puts    
-        shoulds.each do |should|
-          yaml_to_context( should, indent + 1 ) and next if should.is_a?( Hash )
-          puts indent2 + "should_eventually \"" + should.gsub(/^should +/,'') + "\" do" 
-          puts indent2 + "end" 
-          puts
-        end
-        puts indent1 + "end" 
-      end
-    end 
-    
-    puts("Please pass in a FILE argument.") and exit unless ENV['FILE']
-      
-    yaml_to_context( YAML.load_file( ENV['FILE'] ) )
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/tasks.rb

@@ -1,3 +0,0 @@
-Dir[File.join(File.dirname(__FILE__), 'tasks', '*.rake')].each do |f|
-  load f
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/test_unit.rb

@@ -1,22 +0,0 @@
-require 'test/unit'
-
-require 'shoulda/context'
-require 'shoulda/proc_extensions'
-require 'shoulda/assertions'
-require 'shoulda/macros'
-require 'shoulda/helpers'
-require 'shoulda/autoload_macros'
-require 'shoulda/rails' if defined? RAILS_ROOT
-
-module Test # :nodoc: all
-  module Unit
-    class TestCase
-      include Shoulda::InstanceMethods
-      extend Shoulda::ClassMethods
-      include Shoulda::Assertions
-      extend Shoulda::Macros
-      include Shoulda::Helpers
-    end
-  end
-end
-

data/vendor/gems/shoulda-2.10.2/lib/shoulda.rb

@@ -1,9 +0,0 @@
-module Shoulda
-  VERSION = "2.10.2"
-end
-
-if defined? Spec
-  require 'shoulda/rspec'
-else
-  require 'shoulda/test_unit'
-end

data/vendor/gems/shoulda-2.10.2/rails/init.rb

@@ -1,7 +0,0 @@
-if RAILS_ENV == 'test'
-  if defined? Spec
-    require 'shoulda/rspec'
-  else
-    require 'shoulda/rails' 
-  end
-end

data/vendor/gems/shoulda-2.10.2/test/README

@@ -1,36 +0,0 @@
-The Shoulda test suite (in particular - the tests that test shoulda)
-
-Quick overview:
-
-The test directory contains the following files and subdirectories:
-
-* rails_root - contains the stripped down rails application that the tests run against.  The rails root contains:
-** the models, controllers, and views defined under app/
-** the test.rb environment file
-** a migration file for each model
-** a shoulda initializer that simulates loading the plugin but without relying on vendor/plugins
-* fixtures - contain the sample DB data for each model
-* functional - controller tests for each of the controllers under rails_root/app
-* unit - model tests for each of the models under rails_root/app
-* other - tests for the shoulda contexts, should statements, and assertions
-* test_helper.rb - responsible for initializing the test environment
-** sets the rails_env to test
-** sets the rails_root
-** runs all the migrations against the in-memory sqlite3 db
-** adds some magic to load the right fixture files
-
-In order to add a new model (or controller) to the test suite:
-
-* add that model to rails_root/app/models
-* add a migration for that model
-* add a fixture file
-* add a test for that file under test/units
-
-Dependencies:
-
-* Rails gem installed in the host system
-* A working sqlite3 installation.
-
-If you have problems running these tests, please notify the mailing list:  shoulda@googlegroups.com
-
-- Tammer Saleh <tsaleh@thoughtbot.com>

data/vendor/gems/shoulda-2.10.2/test/fail_macros.rb

@@ -1,39 +0,0 @@
-module Shoulda
-  class << self
-    attr_accessor :expected_exceptions
-  end
-
-  module ClassMethods
-    # Enables the core shoulda test suite to test for failure scenarios.  For
-    # example, to ensure that a set of test macros should fail, do this:
-    #
-    #   should_fail do
-    #     should_validate_presence_of :comments
-    #     should_not_allow_mass_assignment_of :name
-    #   end
-    def should_fail(&block)
-      context "should fail when trying to run:" do
-        if defined?(Test::Unit::AssertionFailedError)
-          failures = [Test::Unit::AssertionFailedError]
-        elsif defined?(MiniTest::Assertion)
-          failures = [MiniTest::Assertion]
-        end
-        Shoulda.expected_exceptions = failures
-        yield block
-        Shoulda.expected_exceptions = nil
-      end
-    end
-  end
-
-  class Context
-    # alias_method_chain hack to allow the should_fail macro to work
-    def should_with_failure_scenario(name, options = {}, &block)
-      if Shoulda.expected_exceptions
-        expected_exceptions = Shoulda.expected_exceptions
-        failure_block = lambda { assert_raise(*expected_exceptions, &block.bind(self)) }
-      end
-      should_without_failure_scenario(name, options, &(failure_block || block))
-    end
-    alias_method_chain :should, :failure_scenario
-  end
-end

data/vendor/gems/shoulda-2.10.2/test/fixtures/addresses.yml

@@ -1,3 +0,0 @@
-first:
-  title: Home
-  addressable: first (User)

data/vendor/gems/shoulda-2.10.2/test/fixtures/posts.yml

@@ -1,5 +0,0 @@
-first:
-  id: 1
-  title: My Cute Kitten!
-  body: This is totally a cute kitten
-  user_id: 1

data/vendor/gems/shoulda-2.10.2/test/fixtures/tags.yml

@@ -1,9 +0,0 @@
-first:
-  id: 1
-  name: Stuff
-second:
-  id: 2
-  name: Rails
-third:
-  id: 3
-  name: Nothing

data/vendor/gems/shoulda-2.10.2/test/fixtures/users.yml

@@ -1,6 +0,0 @@
-first:
-  id: 1
-  name: Some dude
-  age: 2
-  email: none@none.com
-  ssn: 123456789

data/vendor/gems/shoulda-2.10.2/test/functional/posts_controller_test.rb

@@ -1,121 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'posts_controller'
-
-# Re-raise errors caught by the controller.
-class PostsController; def rescue_action(e) raise e end; end
-
-class PostsControllerTest < ActionController::TestCase
-  fixtures :all
-
-  def setup
-    @controller = PostsController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    @post       = Post.find(:first)
-  end
-
-  # autodetects the :controller
-  should_route :get,    '/posts',     :action => :index
-  # explicitly specify :controller
-  should_route :post,   '/posts',     :controller => :posts, :action => :create
-  # non-string parameter
-  should_route :get,    '/posts/1',   :action => :show, :id => 1
-  # string-parameter
-  should_route :put,    '/posts/1',   :action => :update, :id => "1"
-  should_route :delete, '/posts/1',   :action => :destroy, :id => 1
-  should_route :get,    '/posts/new', :action => :new
-
-  # Test the nested routes
-  should_route :get,    '/users/5/posts',     :action => :index, :user_id => 5
-  should_route :post,   '/users/5/posts',     :action => :create, :user_id => 5
-  should_route :get,    '/users/5/posts/1',   :action => :show, :id => 1, :user_id => 5
-  should_route :delete, '/users/5/posts/1',   :action => :destroy, :id => 1, :user_id => 5
-  should_route :get,    '/users/5/posts/new', :action => :new, :user_id => 5
-  should_route :put,    '/users/5/posts/1',   :action => :update, :id => 1, :user_id => 5
-
-  context "Logged in" do
-    setup do
-      @request.session[:logged_in] = true
-    end
-
-    context "viewing posts for a user" do
-      setup do
-        get :index, :user_id => users(:first)
-      end
-      should_respond_with :success
-      should_assign_to :user, :class => User
-      should_render_template :index
-      should_assign_to(:user) { users(:first) }
-      should_fail do
-        should_assign_to :user, :class => Post
-      end
-      should_fail do
-        should_assign_to(:user) { posts(:first) }
-      end
-      should_assign_to :posts
-      should_not_assign_to :foo, :bar
-      should_render_page_with_metadata :description => /Posts/, :title => /index/
-      should_render_page_with_metadata :keywords => "posts"
-    end
-
-    context "viewing posts for a user with rss format" do
-      setup do
-        get :index, :user_id => users(:first), :format => 'rss'
-        @user = users(:first)
-      end
-      should_respond_with :success
-      should_respond_with_content_type 'application/rss+xml'
-      should_respond_with_content_type :rss
-      should_respond_with_content_type /rss/
-      should_set_session(:mischief) { nil }
-      should_set_session(:special) { '$2 off your next purchase' }
-      should_set_session(:special_user_id) { @user.id }
-      should_set_session(:false_var) { false }
-      should_fail do
-        should_set_session(:special_user_id) { 'value' }
-      end
-      should_assign_to :user, :posts
-      should_not_assign_to :foo, :bar
-    end
-
-    context "viewing a post on GET to #show" do
-      setup { get :show, :user_id => users(:first), :id => posts(:first) }
-      should_render_with_layout 'wide'
-      context "with a symbol" do # to avoid redefining a test
-        should_render_with_layout :wide
-      end
-      should_assign_to :false_flag
-      should_set_the_flash_to nil
-      should_fail do
-        should_set_the_flash_to /.*/
-      end
-    end
-
-    context "on GET to #new" do
-      setup { get :new, :user_id => users(:first) }
-      should_render_without_layout
-      should_not_set_the_flash
-      should_render_a_form
-    end
-
-    context "on POST to #create" do
-      setup do
-        post :create, :user_id => users(:first),
-                      :post    => { :title => "first post",
-                                    :body  => 'blah blah blah' }
-      end
-
-      should_redirect_to('the created post') { user_post_url(users(:first),
-                                                             assigns(:post)) }
-      should_fail do
-        should_redirect_to('elsewhere') { user_posts_url(users(:first)) }
-      end
-
-      should_set_the_flash_to /success/
-      should_fail do
-        should_not_set_the_flash
-      end
-    end
-  end
-
-end

data/vendor/gems/shoulda-2.10.2/test/functional/users_controller_test.rb

@@ -1,19 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'users_controller'
-
-# Re-raise errors caught by the controller.
-class UsersController; def rescue_action(e) raise e end; end
-
-class UsersControllerTest < ActionController::TestCase
-  fixtures :all
-
-  def setup
-    @controller = UsersController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    @user       = User.find(:first)
-  end
-  
-  should_filter_params :ssn
-
-end

data/vendor/gems/shoulda-2.10.2/test/matchers/active_record/allow_mass_assignment_of_matcher_test.rb

@@ -1,68 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class AllowMassAssignmentOfMatcherTest < ActiveSupport::TestCase # :nodoc:
-
-  context "an attribute that is blacklisted from mass-assignment" do
-    setup do
-      define_model :example, :attr => :string do
-        attr_protected :attr
-      end
-      @model = Example.new
-    end
-
-    should "reject being mass-assignable" do
-      assert_rejects allow_mass_assignment_of(:attr), @model
-    end
-  end
-
-  context "an attribute that is not whitelisted for mass-assignment" do
-    setup do
-      define_model :example, :attr => :string, :other => :string do
-        attr_accessible :other
-      end
-      @model = Example.new
-    end
-
-    should "reject being mass-assignable" do
-      assert_rejects allow_mass_assignment_of(:attr), @model
-    end
-  end
-
-  context "an attribute that is whitelisted for mass-assignment" do
-    setup do
-      define_model :example, :attr => :string do
-        attr_accessible :attr
-      end
-      @model = Example.new
-    end
-
-    should "accept being mass-assignable" do
-      assert_accepts allow_mass_assignment_of(:attr), @model
-    end
-  end
-
-  context "an attribute not included in the mass-assignment blacklist" do
-    setup do
-      define_model :example, :attr => :string, :other => :string do
-        attr_protected :other
-      end
-      @model = Example.new
-    end
-
-    should "accept being mass-assignable" do
-      assert_accepts allow_mass_assignment_of(:attr), @model
-    end
-  end
-
-  context "an attribute on a class with no protected attributes" do
-    setup do
-      define_model :example, :attr => :string
-      @model = Example.new
-    end
-
-    should "accept being mass-assignable" do
-      assert_accepts allow_mass_assignment_of(:attr), @model
-    end
-  end
-
-end