giraffesoft-attribute_fu 0.2

data/test/vendor/plugins/shoulda/lib/shoulda/context.rb

@@ -0,0 +1,143 @@
+module ThoughtBot # :nodoc:
+  module Shoulda # :nodoc:
+    # = context and should blocks
+    # 
+    # A context block groups should statements under a common setup/teardown method.  
+    # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
+    # and readability of your test code.
+    #
+    # A context block can contain setup, should, should_eventually, and teardown blocks.
+    #
+    #  class UserTest << Test::Unit::TestCase
+    #    context "a User instance" do
+    #      setup do
+    #        @user = User.find(:first)
+    #      end
+    #    
+    #      should "return its full name"
+    #        assert_equal 'John Doe', @user.full_name
+    #      end
+    #    end
+    #  end
+    #
+    # This code will produce the method <tt>"test a User instance should return its full name"</tt>.
+    #
+    # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each test.  
+    # They then run their teardown blocks from in to out after each test.
+    #
+    #  class UserTest << Test::Unit::TestCase
+    #    context "a User instance" do
+    #      setup do
+    #        @user = User.find(:first)
+    #      end
+    #    
+    #      should "return its full name"
+    #        assert_equal 'John Doe', @user.full_name
+    #      end
+    #    
+    #      context "with a profile" do
+    #        setup do
+    #          @user.profile = Profile.find(:first)
+    #        end
+    #      
+    #        should "return true when sent :has_profile?"
+    #          assert @user.has_profile?
+    #        end
+    #      end
+    #    end
+    #  end
+    #
+    # This code will produce the following methods 
+    # * <tt>"test: a User instance should return its full name."</tt>
+    # * <tt>"test: a User instance with a profile should return true when sent :has_profile?."</tt>
+    #
+    # <b>A context block can exist next to normal <tt>def test_the_old_way; end</tt> tests</b>, 
+    # meaning you do not have to fully commit to the context/should syntax in a test file.
+    #
+  
+    module Context
+      def Context.included(other) # :nodoc:
+        @@context_names   = []
+        @@setup_blocks    = []
+        @@teardown_blocks = []
+      end
+    
+      # Defines a test method.  Can be called either inside our outside of a context.
+      # Optionally specify <tt>:unimplimented => true</tt> (see should_eventually).
+      #
+      # Example:
+      #
+      #   class UserTest << Test::Unit::TestCase 
+      #     should "return first user on find(:first)"
+      #       assert_equal users(:first), User.find(:first)
+      #     end
+      #   end
+      #
+      # Would create a test named
+      #   'test: should return first user on find(:first)'
+      #
+      def should(name, opts = {}, &should_block)
+        test_name = ["test:", @@context_names, "should", "#{name}. "].flatten.join(' ').to_sym
+
+        name_defined = eval("self.instance_methods.include?('#{test_name.to_s.gsub(/['"]/, '\$1')}')", should_block.binding)
+        raise ArgumentError, "'#{test_name}' is already defined" and return if name_defined
+      
+        setup_blocks    = @@setup_blocks.dup
+        teardown_blocks = @@teardown_blocks.dup
+      
+        if opts[:unimplemented]
+          define_method test_name do |*args|
+            # XXX find a better way of doing this.
+            assert true
+        	  STDOUT.putc "X" # Tests for this model are missing.
+          end    		
+        else
+          define_method test_name do |*args|
+            begin
+              setup_blocks.each {|b| b.bind(self).call }
+              should_block.bind(self).call(*args)
+            ensure
+              teardown_blocks.reverse.each {|b| b.bind(self).call }
+            end
+          end
+        end
+      end
+
+      # Creates a context block with the given name.
+      def context(name, &context_block)
+        saved_setups    = @@setup_blocks.dup
+        saved_teardowns = @@teardown_blocks.dup      
+        saved_contexts  = @@context_names.dup
+
+        @@context_names << name
+        context_block.bind(self).call
+
+        @@context_names   = saved_contexts      
+        @@setup_blocks    = saved_setups
+        @@teardown_blocks = saved_teardowns
+      end
+
+      # Run before every should block in the current context.
+      # If a setup block appears in a nested context, it will be run after the setup blocks
+      # in the parent contexts.
+      def setup(&setup_block)
+        @@setup_blocks << setup_block
+      end
+
+      # Run after every should block in the current context.
+      # If a teardown block appears in a nested context, it will be run before the teardown 
+      # blocks in the parent contexts.
+      def teardown(&teardown_block)
+        @@teardown_blocks << teardown_block
+      end
+
+      # Defines a specification that is not yet implemented.  
+      # Will be displayed as an 'X' when running tests, and failures will not be shown.
+      # This is equivalent to:
+      #   should(name, {:unimplemented => true}, &block)
+      def should_eventually(name, &block)
+        should("eventually #{name}", {:unimplemented => true}, &block)
+      end
+    end
+  end
+end

data/test/vendor/plugins/shoulda/lib/shoulda/general.rb

@@ -0,0 +1,119 @@
+module ThoughtBot # :nodoc:
+  module Shoulda # :nodoc:
+    module General
+      def self.included(other) # :nodoc:
+        other.class_eval do
+          extend ThoughtBot::Shoulda::General::ClassMethods
+          # include ThoughtBot::Shoulda::General::InstanceMethods
+        end
+      end
+      
+      module ClassMethods
+        # Loads all fixture files (<tt>test/fixtures/*.yml</tt>)
+        def load_all_fixtures
+          all_fixtures = Dir.glob(File.join(Test::Unit::TestCase.fixture_path, "*.yml")).collect do |f| 
+            File.basename(f, '.yml').to_sym
+          end
+          fixtures *all_fixtures
+        end
+      end
+      
+      # Prints a message to stdout, tagged with the name of the calling method.
+      def report!(msg = "")
+        puts("#{caller.first}: #{msg}")
+      end
+
+      # Ensures that the number of items in the collection changes
+      #
+      #   assert_difference(User, :count, 1) { User.create }
+      #   assert_difference(User.packages, :size, 3, true) { User.add_three_packages }
+      #
+      # Setting reload to true will call <tt>object.reload</tt> after the block (for ActiveRecord associations)
+      def assert_difference(object, method, difference, reload = false, msg = nil)
+        initial_value = object.send(method)
+        yield
+        object.send(:reload) if reload
+        assert_equal initial_value + difference, object.send(method), (msg || "#{object}##{method} after block")
+      end
+
+      # Ensures that object.method does not change.  See assert_difference for usage.
+      def assert_no_difference(object, method, reload = false, msg = nil, &block)
+        assert_difference(object, method, 0, reload, msg, &block)
+      end
+
+      # Asserts that two arrays contain the same elements, the same number of times.  Essentially ==, but unordered.
+      #
+      #   assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
+      def assert_same_elements(a1, a2, msg = nil)
+        [:select, :inject, :size].each do |m|
+          [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
+        end
+
+        assert a1h = a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h }
+        assert a2h = a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
+
+        assert_equal(a1h, a2h, msg)
+      end
+
+      # Asserts that the given collection contains item x.  If x is a regular expression, ensure that
+      # at least one element from the collection matches x.  +extra_msg+ is appended to the error message if the assertion fails.
+      #
+      #   assert_contains(['a', '1'], /\d/) => passes
+      #   assert_contains(['a', '1'], 'a') => passes
+      #   assert_contains(['a', '1'], /not there/) => fails
+      def assert_contains(collection, x, extra_msg = "")
+        collection = [collection] unless collection.is_a?(Array)
+        msg = "#{x.inspect} not found in #{collection.to_a.inspect} " + extra_msg
+        case x
+        when Regexp: assert(collection.detect { |e| e =~ x }, msg)
+        else         assert(collection.include?(x), msg)
+        end        
+      end
+
+      # Asserts that the given collection does not contain item x.  If x is a regular expression, ensure that
+      # none of the elements from the collection match x.
+      def assert_does_not_contain(collection, x, extra_msg = "")
+        collection = [collection] unless collection.is_a?(Array)
+        msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
+        case x
+        when Regexp: assert(!collection.detect { |e| e =~ x }, msg)
+        else         assert(!collection.include?(x), msg)
+        end        
+      end
+      
+      # Asserts that the given object can be saved
+      #
+      #  assert_save User.new(params)
+      def assert_save(obj)
+        assert obj.save, "Errors: #{obj.errors.full_messages.join('; ')}"
+        obj.reload
+      end
+
+      # Asserts that the given object is valid
+      #
+      #  assert_save User.new(params)
+      def assert_valid(obj)
+        assert obj.valid?, "Errors: #{obj.errors.full_messages.join('; ')}"
+      end
+      
+      # Asserts that the block uses ActionMailer to send emails
+      #
+      #  assert_sends_email(2) { Mailer.deliver_messages }
+      def assert_sends_email(num = 1, &blk)
+        ActionMailer::Base.deliveries.clear
+        blk.call
+        msg = "Sent #{ActionMailer::Base.deliveries.size} emails, when #{num} expected:\n"
+        ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
+        assert(num == ActionMailer::Base.deliveries.size, msg)
+      end
+
+      # Asserts that the block does not send emails thorough ActionMailer
+      #
+      #  assert_does_not_send_email { # do nothing }
+      def assert_does_not_send_email(&blk)
+        assert_sends_email 0, &blk
+      end
+      
+    end
+  end
+end

data/test/vendor/plugins/shoulda/lib/shoulda/private_helpers.rb

@@ -0,0 +1,17 @@
+module ThoughtBot # :nodoc:
+  module Shoulda # :nodoc:
+    module Private # :nodoc:
+      def get_options!(args, *wanted)
+        ret  = []
+        opts = (args.last.is_a?(Hash) ? args.pop : {})
+        wanted.each {|w| ret << opts.delete(w)}
+        raise ArgumentError, "Unsuported options given: #{opts.keys.join(', ')}" unless opts.keys.empty?
+        return *ret
+      end
+
+      def model_class
+        self.name.gsub(/Test$/, '').constantize
+      end
+    end
+  end
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: giraffesoft-attribute_fu
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: 
+- James Golick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-04 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Creating multi-model forms is amazingly easy with AttributeFu.
+email: james@giraffesoft.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- init.rb
+- lib
+- lib/attribute_fu
+- lib/attribute_fu/associated_form_helper.rb
+- lib/attribute_fu/associations.rb
+- lib/attribute_fu.rb
+- MIT-LICENSE
+- Rakefile
+- README
+- tasks
+- tasks/attribute_fu_tasks.rake
+- test
+- test/app
+- test/app/controllers
+- test/app/controllers/application.rb
+- test/app/helpers
+- test/app/helpers/application_helper.rb
+- test/app/models
+- test/app/models/comment.rb
+- test/app/models/photo.rb
+- test/config
+- test/config/boot.rb
+- test/config/database.yml
+- test/config/environment.rb
+- test/config/environments
+- test/config/environments/development.rb
+- test/config/environments/test.rb
+- test/config/routes.rb
+- test/db
+- test/db/migrate
+- test/db/migrate/001_create_photos.rb
+- test/db/migrate/002_create_comments.rb
+- test/db/schema.rb
+- test/Rakefile
+- test/script
+- test/script/console
+- test/script/destroy
+- test/script/generate
+- test/script/server
+- test/test
+- test/test/test_helper.rb
+- test/test/unit
+- test/test/unit/associated_form_helper_test.rb
+- test/test/unit/comment_test.rb
+- test/test/unit/photo_test.rb
+- test/vendor
+- test/vendor/plugins
+- test/vendor/plugins/shoulda
+- test/vendor/plugins/shoulda/init.rb
+- test/vendor/plugins/shoulda/lib
+- test/vendor/plugins/shoulda/lib/shoulda
+- test/vendor/plugins/shoulda/lib/shoulda/active_record_helpers.rb
+- test/vendor/plugins/shoulda/lib/shoulda/context.rb
+- test/vendor/plugins/shoulda/lib/shoulda/general.rb
+- test/vendor/plugins/shoulda/lib/shoulda/private_helpers.rb
+- test/vendor/plugins/shoulda/lib/shoulda.rb
+- uninstall.rb
+has_rdoc: true
+homepage: http://jamesgolick.com/attribute_fu
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: rails multi-model forms made easy!
+test_files: []
+