shoulda_create 0.0.1

data/README.rdoc

@@ -0,0 +1,22 @@
+== shoulda_create
+
+Restores should_create functionality to shoulda.
+
+I like using should_create and friends to make assertions about records coming and going in the database.
+
+Shoulda did, but doesn't any more. With this, it can again.
+
+Some ideological dispute, I guess.  I complained to one of the thoughtbot guys, and he said "that's the joy of open source, you can build your own".  Well, here it is.
+
+== Example
+
+  context 'POST to :create' do
+    setup { post :create, :email => 'bob@example.com', :name => 'Bob Dobbs' }
+    should_create :user
+  end
+
+== License
+
+shoulda_create is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT

data/lib/shoulda_create.rb

@@ -0,0 +1,3 @@
+require 'shoulda'
+require 'shoulda_create/shoulda_create'
+require 'shoulda_create/test_unit'

data/lib/shoulda_create/shoulda_create.rb

@@ -0,0 +1,84 @@
+module ShouldaCreate
+  def should_change_record_count_of(class_name, amount, action) # :nodoc:
+    klass = class_name.to_s.camelize.constantize
+    var_name = "@_before_change_record_count_#{class_name}"
+    before = lambda do
+      instance_variable_set var_name, klass.count
+    end
+    human_name = class_name.to_s.humanize.downcase
+    count = 'a'
+    if amount > 1
+      human_name = human_name.pluralize
+      count = amount
+    end
+    should "#{action} #{count} #{human_name}", :before => before do
+      assert_equal instance_variable_get(var_name) + amount,
+                   klass.count,
+                   "Expected to #{action} a #{human_name}"
+    end
+  end
+
+  def should_not_change_record_count_of(class_name) # :nodoc:
+    should_change_record_count_of class_name, 0, 'neither create nor destroy'
+  end
+
+  def should_not_create class_name
+    should_change_record_count_of(class_name, 0, 'create')
+  end
+
+  def should_create(class_name, options = {})
+    count = options[:count] || 1
+    should_change_record_count_of(class_name, count, 'create')
+  end
+
+  def should_destroy(class_name, options = {})
+    count = options[:count] || -1
+    should_change_record_count_of(class_name, count, 'destroy')
+  end
+
+  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_var_name = '@_before_should_change_' + description.downcase.gsub(/[^\w]/, '_')
+    before = lambda { self.instance_variable_set( before_var_name, code.bind(self).call ) }
+    should stmt, :before => before do
+      old_value = self.instance_variable_get( before_var_name )
+      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
+
+  def should_not_change(description, &block)
+
+    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_var_name = '@_before_should_change_' + description.downcase.gsub(/[^\w]/, '_')
+    before = lambda { self.instance_variable_set( before_var_name, code.bind(self).call ) }
+    should "not change #{description}", :before => before do
+      old_value = self.instance_variable_get( before_var_name )
+      new_value = code.bind(self).call
+      assert_equal old_value, new_value, "#{description} changed"
+    end
+  end
+end

data/lib/shoulda_create/test_unit.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+
+Test::Unit::TestCase.extend(ShouldaCreate)

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: shoulda_create
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Bill Kirtley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-16 00:00:00 Z
+dependencies: []
+
+description: I like using should_create and friends to make assertions about records coming and going in the database. Shoulda did, but doesn't any more.  With this, it can again.
+email: bill.kirtley@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/shoulda_create/shoulda_create.rb
+- lib/shoulda_create/test_unit.rb
+- lib/shoulda_create.rb
+- README.rdoc
+homepage: http://github.com/cluesque/shoulda_create
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Restores should_create functionality to shoulda.
+test_files: []
+