simply_stated 0.0.3 → 0.0.4

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/array_test.rb

@@ -0,0 +1,48 @@
+require File.instance_eval { expand_path join(dirname(__FILE__), 'test_helper') }
+require 'freighthopper'
+
+class ArrayTest < Test::Unit::TestCase
+  context 'singular' do
+    should 'return the singular object if there is indeed only one' do
+      assert_singular 5, [5]
+    end
+    
+    should 'return nil if the array is empty' do
+      assert_singular nil, []
+    end
+    
+    should 'return nil if the array has > 1 item' do
+      assert_singular nil, [1, 2]
+    end
+  end
+  
+  context 'singular questionmark' do
+    should 'return true if the array has only one member' do
+      assert_singular [5]
+    end
+    
+    should 'return false if the array is empty' do
+      assert_not_singular []
+    end
+    
+    should 'return false if the array has more than one member' do
+      assert_not_singular [1, 2]
+    end
+  end
+  
+  context 'singular bang' do
+    should 'return the item if there is just one' do
+      assert_equal 5, [5].singular!
+    end
+    
+    should 'raise if there are no items' do
+      e = assert_raise(RuntimeError){ [].singular! }
+      assert_message 'not singular', e
+    end
+
+    should 'raise if there are more than one item' do
+      e = assert_raise(RuntimeError){ [1, 2].singular! }
+      assert_message 'not singular', e
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/define_and_alias_test.rb

@@ -0,0 +1,48 @@
+require File.instance_eval { expand_path join(dirname(__FILE__), 'test_helper') }
+require 'freighthopper'
+
+class DefineAndAliasTest < Test::Unit::TestCase
+  class SomeClass
+    attr_reader :cache
+    def foo() 5 end
+
+    define_and_alias(:foo, :bar) {foo_without_bar + 5}
+  
+    def even?(number) number % 2 == 0 end
+    
+    define_and_alias :even?, :caching do |number|
+      (@cache ||= {})[number] ||= even_without_caching?(number)
+    end
+  end
+  
+  context 'with a SomeClass' do
+    setup {@object = SomeClass.new}
+
+    should 'respond to foo_with_bar' do
+      assert @object.respond_to?('foo_with_bar')
+    end
+
+    should 'respond to foo_without_bar' do
+      assert @object.respond_to?('foo_without_bar')
+    end
+
+    should 'return 5 for foo_without_bar' do
+      assert_foo_without_bar 5, @object
+    end
+
+    should 'return 10 for foo' do
+      assert_foo 10, @object
+    end
+
+    should 'handle questionmark methods' do
+      %w(even? even_without_caching? even_with_caching?).each do |method|
+        assert @object.respond_to?(method)
+      end
+    end
+  
+    should 'pass arguments' do
+      assert @object.even?(4)
+      assert_length 1, @object.cache
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/float_test.rb

@@ -0,0 +1,18 @@
+require File.instance_eval { expand_path join(dirname(__FILE__), 'test_helper') }
+require 'freighthopper'
+
+class FloatTest < Test::Unit::TestCase
+  context 'to_s with format' do
+    should 'work as before' do
+      assert_to_s '1.1', 1.1
+    end
+    
+    should 'allow specification of a format string' do
+      assert_equal "1.2", 1.23.to_s("%.1f")
+    end
+    
+    should 'allow specification of a precision' do
+      assert_equal '1.2', 1.23.to_s(1)
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/hash_test.rb

@@ -0,0 +1,27 @@
+require File.instance_eval { expand_path join(dirname(__FILE__), 'test_helper') }
+require 'freighthopper'
+
+class HashTest < Test::Unit::TestCase
+  context 'map_keys' do
+    should 'replace keys with their mapped replacement' do
+      base = {:hello => :world}
+      expected = {:howdy => :world}
+      assert_equal expected, base.map_keys(:hello => :howdy)
+    end
+    
+    should 'not modify keys that are not specified' do
+      base = {:a => 1, :b => 2}
+      mapping = {:a => :hello}
+      expected = {:hello => 1, :b => 2}
+      
+      assert_equal expected, base.map_keys(mapping)
+    end
+    
+    should 'ignore mappings that do not exist' do
+      base = {:a => 1, :b => 2}
+      mapping = {:q => :r}
+
+      assert_equal base, base.map_keys(mapping)
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/kernel_test.rb

@@ -0,0 +1,34 @@
+require File.instance_eval { expand_path join(dirname(__FILE__), 'test_helper') }
+require 'freighthopper'
+
+class KernelTest < Test::Unit::TestCase
+  context 'trace output' do
+    context 'without Kernel trace_output' do
+      should 'function as normal' do
+        output = capture(false) { puts 'hello' }
+        assert_equal "hello\n", output
+      end
+    end
+    
+    context 'with Kernel trace_output' do
+      should 'include the line that printed' do
+        output = capture(true) { puts 'hello' }
+        assert_equal "#{__FILE__}:15:in `puts'\nhello\n\n", output
+      end
+    end
+  end
+  
+  private
+  def capture(trace_output, &block)
+    Kernel.trace_output = trace_output
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+    Kernel.trace_output = false
+   fake.string
+  end
+end

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/lazy_alias_test.rb

@@ -0,0 +1,34 @@
+require File.instance_eval { expand_path join(dirname(__FILE__), 'test_helper') }
+require 'freighthopper'
+
+class DefineAndAliasTest < Test::Unit::TestCase
+  class SomeClass
+    attr_reader :last_method_missing, :last_args
+    lazy_alias :this_method_is_called, :this_hits_method_missing
+    
+    def method_missing(*args)
+      @last_method_missing = args.shift
+      @last_args = args
+    end
+  end
+  
+  context 'with a SomeClass' do
+    setup {@object = SomeClass.new}
+
+    should 'respond to this_method_is_called' do
+      assert @object.respond_to?(:this_method_is_called)
+    end
+    
+    context "after calling this_method_is_called" do
+      setup {@object.this_method_is_called :arg1, :arg2}
+      
+      should 'call whatever method is the second argument' do
+        assert_last_method_missing :this_hits_method_missing, @object
+      end
+      
+      should 'pass through args' do
+        assert_last_args [:arg1, :arg2], @object
+      end
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/object_test.rb

@@ -0,0 +1,68 @@
+require File.instance_eval { expand_path join(dirname(__FILE__), 'test_helper') }
+require 'freighthopper'
+
+class ObjectTest < Test::Unit::TestCase
+  context 'soft_send' do
+    should 'send the method if the object responds to it' do
+      assert_equal 1, [1].soft_send(:first)
+    end
+    
+    should 'return nil if the object does not' do
+      assert_nil 5.soft_send(:hello)
+    end
+    
+    should 'pass args' do
+      assert_equal 10, 5.soft_send(:*, 2)
+    end
+  end
+  
+  context 'eval_with_options' do
+    setup do
+      def foo(arg1, options = {})
+        [arg1, options]
+      end
+    end
+    
+    should 'pass options to any method called in the block' do
+      returned = nil
+
+      eval_with_options :wibble => :baz do
+        returned = foo(:squee)
+      end
+      
+      assert_equal [:squee, {:wibble => :baz}], returned
+    end
+  end
+  
+  context 'or_if_blank' do
+    should 'return nil if there is no block and the argument is nil' do
+      assert_nil "".or_if_blank(nil)
+    end
+    
+    should 'return the callee if it is not blank' do
+      assert_equal "hello", "hello".or_if_blank(5)
+    end
+    
+    should 'return the first arg if the callee is blank' do
+      assert_equal 5, "".or_if_blank(5)
+    end
+    
+    should 'accept a block' do
+      assert_equal 5, "".or_if_blank{5}
+    end
+  end
+  
+  context 'is_one_of?' do
+    should 'check if the object is one of the arguments' do
+      assert "hello".is_one_of?(Fixnum, Symbol, Proc, String)
+    end
+    
+    should 'work with an array as well' do
+      assert :symbol.is_one_of?([Fixnum, Symbol])
+    end
+    
+    should 'return false if there is no match' do
+      assert_not :symbol.is_one_of?(Proc, String)
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/string_test.rb

@@ -0,0 +1,58 @@
+require File.instance_eval { expand_path join(dirname(__FILE__), 'test_helper') }
+require 'freighthopper'
+
+class StringTest < Test::Unit::TestCase
+  context 'strip' do
+    should 'still allow normal strip' do
+      assert_strip "hello", " hello \t\n"
+    end
+    
+    should 'also allow a string' do
+      assert_equal "hello", "---hello---".strip("-")
+    end
+    
+    should 'also allow a regular expression' do
+      assert_equal "hello", "123hello456".strip(/[0-9]/)
+    end
+  end
+  
+  context 'division operator' do
+    context 'with an even division' do
+      should 'split the string into that many even strings' do
+        divided = ('-' * 10) / 2
+        assert_size 2, divided
+        assert_equal [5, 5], divided.map{|s| s.length}
+      end
+    end
+    
+    context 'with an uneven division' do
+      should 'take the difference out of the last one' do
+        divided = ('-' * 10) / 3
+        assert_size 3, divided
+        assert_equal [4,4,2], divided.map(&:length)
+      end
+    end
+  end
+  
+  context 'unindent' do
+    should 'remove the least common leading whitespace' do
+      unindented = (<<-END).unindent
+        a
+          b
+            c
+      END
+      
+      assert_equal "a\n  b\n    c", unindented
+    end
+    
+    should 'replace tabs with tablength' do
+      unindented = "\ttest\n\t\ttest".unindent :tablength => 4
+      assert_equal "test\n    test", unindented
+    end
+
+    should 'replace tabs with tablength (defaulting to 2)' do
+      unindented = "\ttest\n\t\ttest".unindent
+      assert_equal "test\n  test", unindented
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/freighthopper-0.1.2/test/test_helper.rb

@@ -0,0 +1,17 @@
+begin
+  require File.instance_eval { expand_path join(dirname(__FILE__), '..', 'vendor', 'gems', 'environment')}
+rescue LoadError
+  puts "Bundling Gems\n\nHang in there, this only has to happen once...\n\n"
+  system 'gem bundle'
+  retry
+end
+
+Bundler.require_env :test
+
+$:.unshift File.instance_eval { expand_path join(dirname(__FILE__), "..", "lib") }
+require 'test/unit'
+
+
+class Test::Unit::TestCase
+  include TestRig
+end

data/vendor/gems/ruby/1.8/gems/shoulda-2.10.3/CONTRIBUTION_GUIDELINES.rdoc

@@ -0,0 +1,10 @@
+We're using GitHub[http://github.com/thoughtbot/shoulda/tree/master], and we've been getting any combination of github pull requests, tickets, patches, emails, etc.  We need to normalize this workflow to make sure we don't miss any fixes. 
+
+* Make sure you're accessing the source from the {official repository}[http://github.com/thoughtbot/shoulda/tree/master].
+* We prefer git branches over patches, but we can take either.
+* If you're using git, please make a branch for each separate contribution.  We can cherry pick your commits, but pulling from a branch is easier. 
+* If you're submitting patches, please cut each fix or feature into a separate patch.
+* There should be an issue[http://github.com/thoughtbot/shoulda/issues] for any submission.  If you've found a bug and want to fix it, open a new ticket at the same time. 
+* Please <b>don't send pull requests</b>  Just update the issue with the url for your fix (or attach the patch) when it's ready.  The github pull requests pretty much get dropped on the floor until someone with commit rights notices them in the mailbox. 
+* Contributions without tests won't be accepted.  The file <tt>/test/README</tt> explains the testing system pretty thoroughly. 
+

data/vendor/gems/ruby/1.8/gems/shoulda-2.10.3/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007, Tammer Saleh, Thoughtbot, Inc.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/vendor/gems/ruby/1.8/gems/shoulda-2.10.3/README.rdoc

@@ -0,0 +1,171 @@
+= Shoulda - Making tests easy on the fingers and eyes
+
+Shoulda makes it easy to write elegant, understandable, and maintainable tests.  Shoulda consists of test macros, assertions, and helpers added on to the Test::Unit framework.  It's fully compatible with your existing tests, and requires no retooling to use.
+
+Helpers:: #context and #should give you RSpec like test blocks.
+          In addition, you get nested contexts and a much more readable syntax.
+Macros:: Generate hundreds of lines of Controller and ActiveRecord tests with these powerful macros.
+         They get you started quickly, and can help you ensure that your application is conforming to best practices.
+Assertions:: Many common rails testing idioms have been distilled into a set of useful assertions.
+Matchers:: Rspec-compatible matchers providing the same tests as Shoulda macros.
+
+= Usage
+
+=== Context Helpers (Shoulda::Context)
+
+Stop killing your fingers with all of those underscores...  Name your tests with plain sentences!
+
+  class UserTest < Test::Unit::TestCase
+    context "A User instance" do
+      setup do
+        @user = User.find(:first)
+      end
+
+      should "return its full name" do
+        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?" do
+          assert @user.has_profile?
+        end
+      end
+    end
+  end
+
+Produces the following test methods:
+
+  "test: A User instance should return its full name."
+  "test: A User instance with a profile should return true when sent #has_profile?."
+
+So readable!
+
+=== ActiveRecord Tests (Shoulda::ActiveRecord::Macros)
+
+Quick macro tests for your ActiveRecord associations and validations:
+
+  class PostTest < Test::Unit::TestCase
+    fixtures :all
+
+    should_belong_to :user
+    should_have_many :tags, :through => :taggings
+
+    should_validate_uniqueness_of :title
+    should_validate_presence_of :body, :message => /wtf/
+    should_validate_presence_of :title
+    should_validate_numericality_of :user_id
+  end
+
+  class UserTest < Test::Unit::TestCase
+    should_have_many :posts
+
+    should_not_allow_values_for :email, "blah", "b lah"
+    should_allow_values_for :email, "a@b.com", "asdf@asdf.com"
+    should_ensure_length_in_range :email, 1..100
+    should_ensure_value_in_range :age, 1..100
+    should_not_allow_mass_assignment_of :password
+  end
+
+Makes TDD so much easier.
+
+=== Controller Tests (Shoulda::Controller::Macros)
+
+Macros to test the most common controller patterns...
+  
+  class PostsControllerTest < ActionController::TestCase
+    context "on GET to :show for first record" do
+      setup do
+        get :show, :id => 1
+      end
+
+      should_assign_to :user
+      should_respond_with :success
+      should_render_template :show
+      should_not_set_the_flash
+
+      should "do something else really cool" do
+        assert_equal 1, assigns(:user).id
+      end
+    end
+  end
+  
+=== Helpful Assertions (Shoulda::Assertions)
+
+More to come here, but have fun with what's there.
+
+  assert_same_elements([:a, :b, :c], [:c, :a, :b])
+  assert_contains(['a', '1'], /\d/)
+  assert_contains(['a', '1'], 'a')
+
+=== 3rd Party and Application Specific Macros
+
+Any *.rb file under RAILS_ROOT/test/shoulda_macros/ or vendor/(plugins|gems)/gem_name/shoulda_macros/ will be automatically required when you run your tests.  This allows you to distribute macros with your plugins, or to organize the macros inside your application.  Remember to add your macro to Test::Unit::TestCase in the macro file:
+
+  # test/shoulda_macros/security.rb
+  class Test::Unit::TestCase
+    def self.should_be_denied(opts = {})
+      should_set_the_flash_to(opts[:flash] || /Please log in/i)
+      should_redirect_to(opts[:redirect]   || 'login_url')
+    end
+  end
+
+= Rails Installation (Test::Unit)
+
+=== As a Gem
+
+Use this if you prefer to use versioned releases of shoulda.  Specify the gem dependency in your config/environment.rb file:
+
+  Rails::Initializer.run do |config|
+    config.gem "thoughtbot-shoulda", :lib => "shoulda", :source => "http://gems.github.com"
+  end
+
+Then:
+
+  $ rake gems:install
+  $ rake gems:unpack
+
+=== As a Plugin
+
+Use this if you prefer to use the edge version of shoulda:
+
+  $ script/plugin install git://github.com/thoughtbot/shoulda.git
+
+=== As a Plugin (using git submodules)
+
+Use this if you prefer the idea of being able to easily switch between using edge or a tagged version of shoulda:
+
+  $ git submodule add git://github.com/thoughtbot/shoulda.git vendor/plugins/shoulda
+
+= Rails Installation (RSpec)
+
+If you're using Shoulda with RSpec, we recommend that you add config.gem lines
+for RSpec and Shoulda in your config/environment/test.rb file, but do not ask
+Rails to load the RSpec and Shoulda libraries:
+
+  config.gem 'rspec', :lib => false
+  config.gem 'rspec-rails', :lib => false
+  config.gem 'thoughtbot-shoulda',
+             :lib => false,
+             :source => 'http://gems.github.com'
+
+Then require shoulda from your spec/spec_helper.rb file, before Spec::Runner is
+configured:
+
+  # requires for RSpec
+  require 'shoulda'
+  Spec::Runner.configure do |config|
+  # ...
+
+You should not need to require anything besides the top-level shoulda library.
+
+= Credits
+
+Shoulda is maintained by {Tammer Saleh}[mailto:tsaleh@thoughtbot.com], and is funded by Thoughtbot[http://www.thoughtbot.com], inc.
+
+= License
+
+Shoulda is Copyright © 2006-2008 Tammer Saleh, Thoughtbot. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/vendor/gems/ruby/1.8/gems/shoulda-2.10.3/Rakefile

@@ -0,0 +1,72 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift("lib")
+require 'shoulda'
+load 'tasks/shoulda.rake'
+
+# Test::Unit::UI::VERBOSE
+test_files_pattern = 'test/{unit,functional,other,matchers}/**/*_test.rb'
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = test_files_pattern
+  t.verbose = false
+end
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Shoulda -- Making tests easy on the fingers and eyes"
+  rdoc.options << '--line-numbers'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README.rdoc', 'CONTRIBUTION_GUIDELINES.rdoc', 'lib/**/*.rb')
+}
+
+desc "Run code-coverage analysis using rcov"
+task :coverage do
+  rm_rf "coverage"
+  files = Dir[test_files_pattern]
+  system "rcov --rails --sort coverage -Ilib #{files.join(' ')}"
+end
+
+desc 'Update documentation on website'
+task :sync_docs => 'rdoc' do
+  `rsync -ave ssh doc/ dev@dev.thoughtbot.com:/home/dev/www/dev.thoughtbot.com/shoulda`
+end
+
+desc 'Default: run tests.'
+task :default => ['test']
+
+spec = Gem::Specification.new do |s|
+  s.name              = "shoulda"
+  s.version           = Shoulda::VERSION
+  s.summary           = "Making tests easy on the fingers and eyes"
+  s.homepage          = "http://thoughtbot.com/projects/shoulda"
+  s.rubyforge_project = "shoulda"
+
+  s.files       = FileList["[A-Z]*", "{bin,lib,rails,test}/**/*"]
+  s.executables = s.files.grep(/^bin/) { |f| File.basename(f) }
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README.rdoc", "CONTRIBUTION_GUIDELINES.rdoc"]
+  s.rdoc_options     = ["--line-numbers", "--main", "README.rdoc"]
+
+  s.authors = ["Tammer Saleh"]
+  s.email   = "tsaleh@thoughtbot.com"
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Clean files generated by rake tasks"
+task :clobber => [:clobber_rdoc, :clobber_package]
+
+desc "Generate a gemspec file for GitHub"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end

data/vendor/gems/ruby/1.8/gems/shoulda-2.10.3/bin/convert_to_should_syntax

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'tmpdir'
+
+TMP = Dir::tmpdir
+
+def usage(msg = nil)
+  puts "Error: #{msg}" if msg
+  puts if msg
+  puts "Usage: #{File.basename(__FILE__)} normal_test_file.rb"
+  puts
+  puts "Will convert an existing test file with names like "
+  puts
+  puts "  def test_should_do_stuff"
+  puts "    ..."
+  puts "  end"
+  puts
+  puts "to one using the new syntax: "
+  puts
+  puts "  should \"be super cool\" do"
+  puts "    ..."
+  puts "  end"
+  puts
+  puts "A copy of the old file will be left under #{TMP} in case\nthis script just seriously screws up"
+  puts
+  exit (msg ? 2 : 0)
+end
+
+usage("Wrong number of arguments.") unless ARGV.size == 1
+usage("Temp directory '#{TMP}' is not valid. Set TMPDIR environment variable to a writeable directory.") unless File.directory?(TMP) && File.writable?(TMP)
+
+file = ARGV.shift
+tmpfile = File.join(TMP, File.basename(file))
+usage("File '#{file}' doesn't exist") unless File.exists?(file)
+
+FileUtils.cp(file, tmpfile)
+contents = File.read(tmpfile)
+contents.gsub!(/def test_should_(\S+)/) {|line| "should \"#{$1.tr('_', ' ')}\" do"}
+contents.gsub!(/def test_(\S+)/) {|line| "should \"RENAME ME: test #{$1.tr('_', ' ')}\" do"}
+File.open(file, 'w') { |f| f.write(contents) }
+
+puts "File '#{file}' has been converted to 'should' syntax.  Old version has been stored in '#{tmpfile}'"