hubbub 0.0.6

data/lib/vendor/plugins/rspec-rails/spec/spec/rails/mocks/mock_model_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require File.dirname(__FILE__) + '/ar_classes'
+
+describe "mock_model" do
+  describe "responding to interrogation" do
+    before(:each) do
+      @model = mock_model(SubMockableModel)
+    end
+    it "should say it is_a? if it is" do
+      @model.is_a?(SubMockableModel).should be(true)
+    end
+    it "should say it is_a? if it's ancestor is" do
+      @model.is_a?(MockableModel).should be(true)
+    end
+    it "should say it is kind_of? if it is" do
+      @model.kind_of?(SubMockableModel).should be(true)
+    end
+    it "should say it is kind_of? if it's ancestor is" do
+      @model.kind_of?(MockableModel).should be(true)
+    end
+    it "should say it is instance_of? if it is" do
+      @model.instance_of?(SubMockableModel).should be(true)
+    end
+    it "should not say it instance_of? if it isn't, even if it's ancestor is" do
+      @model.instance_of?(MockableModel).should be(false)
+    end
+  end
+
+  describe "with params" do
+    it "should not mutate its parameters" do
+      params = {:a => 'b'}
+      model = mock_model(MockableModel, params)
+      params.should == {:a => 'b'}
+    end
+  end
+
+  describe "with #id stubbed", :type => :view do
+    before(:each) do
+      @model = mock_model(MockableModel, :id => 1)
+    end
+    it "should be named using the stubbed id value" do
+      @model.instance_variable_get(:@name).should == "MockableModel_1"
+    end
+    it "should return string of id value for to_param" do
+      @model.to_param.should == "1"
+    end
+  end
+
+  describe "as association", :type => :view do
+    before(:each) do
+      @real = AssociatedModel.create!
+      @mock_model = mock_model(MockableModel)
+      @real.mockable_model = @mock_model
+    end
+
+    it "should pass associated_model == mock" do
+        @mock_model.should == @real.mockable_model
+    end
+
+    it "should pass mock == associated_model" do
+        @real.mockable_model.should == @mock_model
+    end
+  end
+
+  describe "with :null_object => true", :type => :view do
+    before(:each) do
+      @model = mock_model(MockableModel, :null_object => true, :mocked_method => "mocked")
+    end
+
+    it "should be able to mock methods" do
+      @model.mocked_method.should == "mocked"
+    end
+    it "should return itself to unmocked methods" do
+      @model.unmocked_method.should equal(@model)
+    end
+  end
+
+  describe "#as_null_object", :type => :view do
+    before(:each) do
+      @model = mock_model(MockableModel, :mocked_method => "mocked").as_null_object
+    end
+
+    it "should be able to mock methods" do
+      @model.mocked_method.should == "mocked"
+    end
+    it "should return itself to unmocked methods" do
+      @model.unmocked_method.should equal(@model)
+    end
+  end
+
+  describe "#as_new_record" do
+    it "should say it is a new record" do
+      mock_model(MockableModel).as_new_record.should be_new_record
+    end
+
+    it "should have a nil id" do
+      mock_model(MockableModel).as_new_record.id.should be(nil)
+    end
+
+    it "should return nil for #to_param" do
+      mock_model(MockableModel).as_new_record.to_param.should be(nil)
+    end
+  end
+end
+
+

data/lib/vendor/plugins/rspec-rails/spec/spec/rails/mocks/stub_model_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require File.dirname(__FILE__) + '/ar_classes'
+
+describe "stub_model" do
+  describe "defaults" do
+    it "should have an id" do
+      stub_model(MockableModel).id.should be > 0
+    end
+  
+    it "should say it is not a new record" do
+      stub_model(MockableModel).should_not be_new_record
+    end
+  end
+  
+  it "should accept a stub id" do
+    stub_model(MockableModel, :id => 37).id.should == 37
+  end
+  
+  it "should say it is a new record when id is set to nil" do
+    stub_model(MockableModel, :id => nil).should be_new_record
+  end
+  
+  it "should accept any arbitrary stub" do
+    stub_model(MockableModel, :foo => "bar").foo.should == "bar"
+  end
+  
+  it "should accept a stub for save" do
+    stub_model(MockableModel, :save => false).save.should be(false)
+  end
+  
+  describe "#as_new_record" do
+    it "should say it is a new record" do
+      stub_model(MockableModel).as_new_record.should be_new_record
+    end
+
+    it "should have a nil id" do
+      stub_model(MockableModel).as_new_record.id.should be(nil)
+    end
+  end
+  
+  it "should raise when hitting the db" do
+    lambda do
+      model = stub_model(MockableModel, :changed => true, :attributes_with_quotes => {'this' => 'that'})
+      model.save
+    end.should raise_error(Spec::Rails::IllegalDataAccessException, /stubbed models are not allowed to access the database/)
+  end
+  
+  it "should increment the id" do
+    first = stub_model(MockableModel)
+    second = stub_model(MockableModel)
+    second.id.should == (first.id + 1)
+  end
+  
+  describe "as association" do
+    before(:each) do
+      @real = AssociatedModel.create!
+      @stub_model = stub_model(MockableModel)
+      @real.mockable_model = @stub_model
+    end
+
+    it "should pass associated_model == mock" do
+        @stub_model.should == @real.mockable_model
+    end
+
+    it "should pass mock == associated_model" do
+        @real.mockable_model.should == @stub_model
+    end
+  end
+
+  describe "with a block" do
+    it "should yield the model" do
+      model = stub_model(MockableModel) do |block_arg|
+        @block_arg = block_arg
+      end
+      model.should be(@block_arg)
+    end
+  end
+end
+
+

data/lib/vendor/plugins/rspec-rails/spec/spec/rails/sample_modified_fixture.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "A sample spec", :type => :model do
+  fixtures :animals
+  it "should pass" do
+    animals(:pig).name.should == "Piggy"
+  end
+end

data/lib/vendor/plugins/rspec-rails/spec/spec/rails/sample_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "A sample spec", :type => :model do
+  fixtures :animals
+  it "should pass" do
+    animals(:pig).name.should == "Pig"
+  end
+end

data/lib/vendor/plugins/rspec-rails/spec/spec/rails/spec_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe "script/spec file" do
+  it "should run a spec" do
+    dir = File.dirname(__FILE__)
+    output = `#{RAILS_ROOT}/script/spec #{dir}/sample_spec.rb`
+    unless $?.exitstatus == 0
+      flunk "command 'script/spec spec/sample_spec' failed\n#{output}"
+    end
+  end
+end

data/lib/vendor/plugins/rspec-rails/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+$LOAD_PATH.unshift '../rspec/lib'
+$LOAD_PATH.unshift '../../../'
+$LOAD_PATH.unshift 'spec/resources/controllers'
+$LOAD_PATH.unshift 'spec/resources/helpers'
+
+require '../../../spec/spec_helper'
+
+require 'spec/resources/controllers/application'
+require 'spec/resources/controllers/render_spec_controller'
+require 'spec/resources/controllers/controller_spec_controller'
+require 'spec/resources/controllers/rjs_spec_controller'
+require 'spec/resources/controllers/redirect_spec_controller'
+require 'spec/resources/controllers/action_view_base_spec_controller'
+require 'spec/resources/helpers/addition_helper'
+require 'spec/resources/helpers/explicit_helper'
+require 'spec/resources/helpers/more_explicit_helper'
+require 'spec/resources/helpers/view_spec_helper'
+require 'spec/resources/helpers/plugin_application_helper'
+require 'spec/resources/models/animal'
+require 'spec/resources/models/person'
+require 'spec/resources/models/thing'
+
+unless ActionController::Routing.controller_paths.include?('spec/resources/controllers')
+  ActionController::Routing.instance_eval {@possible_controllers = nil}
+  ActionController::Routing.controller_paths << 'spec/resources/controllers'
+end
+
+module Spec
+  module Rails
+    module Example
+      class ViewExampleGroupController
+        prepend_view_path 'spec/resources/views'
+      end
+    end
+  end
+end
+
+def fail()
+  raise_error(Spec::Expectations::ExpectationNotMetError)
+end
+  
+def fail_with(message)
+  raise_error(Spec::Expectations::ExpectationNotMetError,message)
+end
+
+class Proc
+  def should_pass
+    lambda { self.call }.should_not raise_error
+  end
+end
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect 'action_with_method_restriction', :controller => 'redirect_spec', :action => 'action_with_method_restriction', :conditions => { :method => :get }
+  map.connect 'action_to_redirect_to_action_with_method_restriction', :controller => 'redirect_spec', :action => 'action_to_redirect_to_action_with_method_restriction'
+
+  map.resources :rspec_on_rails_specs
+  map.custom_route 'custom_route', :controller => 'custom_route_spec', :action => 'custom_route'
+  map.connect ':controller/:action/:id'
+end
+
+module HelperMethods
+  def method_in_module_included_in_configuration
+  end
+end
+
+module HelperMacros
+  def accesses_configured_helper_methods
+    it "has access to methods in modules included in configuration" do
+      method_in_module_included_in_configuration
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include HelperMethods
+  config.extend HelperMacros
+end
+

data/lib/vendor/plugins/validation_reflection/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 3
+:patch: 5

data/lib/vendor/plugins/validation_reflection/about.yml

@@ -0,0 +1,7 @@
+author: Michael Schuerig
+summary: Reflection on validations
+homepage: http://rubyforge.org/projects/valirefl/validation_reflection/trunk
+plugin: validation_reflection
+license: MIT
+version: 0.3.1
+rails_version: >= 1.1.6

data/lib/vendor/plugins/validation_reflection/lib/validation_reflection.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+#--
+# Copyright (c) 2006-2008, Michael Schuerig, michael@schuerig.de
+#
+# 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.
+#++
+require 'active_record/reflection'
+require 'ostruct'
+
+# Based on code by Sebastian Kanthak
+# See http://dev.rubyonrails.org/ticket/861
+#
+module ActiveRecordExtensions # :nodoc:
+  module ValidationReflection # :nodoc:
+
+    extend self
+
+    # Look for config/initalizer here in:
+    CONFIG_PATH = ::Dir.glob((::File.join(RAILS_ROOT, 'config', '**', 'validation_reflection.rb').to_s rescue '')).first || ''
+    CORE_VALIDATONS = [
+       :validates_acceptance_of,
+       :validates_associated,
+       :validates_confirmation_of,
+       :validates_exclusion_of,
+       :validates_format_of,
+       :validates_inclusion_of,
+       :validates_length_of,
+       :validates_numericality_of,
+       :validates_presence_of,
+       :validates_uniqueness_of,
+     ].freeze
+     
+    @@reflected_validations = CORE_VALIDATONS.dup
+    @@in_ignored_subvalidation = false
+
+    mattr_accessor  :reflected_validations,
+                    :in_ignored_subvalidation
+
+    def included(base) # :nodoc:
+      return if base.kind_of?(::ActiveRecordExtensions::ValidationReflection::ClassMethods)
+      base.extend(ClassMethods)
+    end
+
+    # Load config/initializer on load, where ValidationReflection defaults
+    # (such as which validations to reflect upon) cane be overridden/extended.
+    #
+    def load_config
+      if ::File.file?(CONFIG_PATH)
+        config = ::OpenStruct.new
+        config.reflected_validations = @@reflected_validations
+        silence_warnings do
+          eval(::IO.read(CONFIG_PATH), binding, CONFIG_PATH)
+        end
+      end
+    end
+
+    # Iterate through all validations and store/cache the info
+    # for later easy access.
+    #
+    def install(base)
+      @@reflected_validations.each do |validation_type|
+        next if base.respond_to?(:"#{validation_type}_with_reflection")
+        ignore_subvalidations = false
+        
+        if validation_type.kind_of?(::Hash)
+          ignore_subvalidations = validation_type[:ignore_subvalidations]
+          validation_type = validation_type[:method]
+        end
+        
+        base.class_eval %{
+          class << self
+            def #{validation_type}_with_reflection(*attr_names)
+              ignoring_subvalidations(#{ignore_subvalidations}) do
+                #{validation_type}_without_reflection(*attr_names)
+                remember_validation_metadata(:#{validation_type}, *attr_names)
+              end
+            end
+            alias_method_chain :#{validation_type}, :reflection
+          end
+        }, __FILE__, __LINE__
+      end
+    end
+    alias :reload :install
+
+    module ClassMethods
+
+      include ::ActiveRecordExtensions::ValidationReflection
+
+      # Returns an array of MacroReflection objects for all validations in the class
+      def reflect_on_all_validations
+        self.read_inheritable_attribute(:validations) || []
+      end
+
+      # Returns an array of MacroReflection objects for all validations defined for the field +attr_name+.
+      def reflect_on_validations_for(attr_name)
+        self.reflect_on_all_validations.select do |reflection|
+          reflection.name == attr_name.to_sym
+        end
+      end
+
+      private
+
+        # Store validation info for easy and fast access.
+        #
+        def remember_validation_metadata(validation_type, *attr_names)
+          configuration = attr_names.last.is_a?(::Hash) ? attr_names.pop : {}
+          attr_names.each do |attr_name|
+            self.write_inheritable_array :validations,
+              [::ActiveRecord::Reflection::MacroReflection.new(validation_type, attr_name.to_sym, configuration, self)]
+          end
+        end
+
+        def ignoring_subvalidations(ignore)
+          save_ignore = self.in_ignored_subvalidation
+          unless self.in_ignored_subvalidation
+            self.in_ignored_subvalidation = ignore
+            yield
+          end
+        ensure
+          self.in_ignored_subvalidation = save_ignore
+        end
+
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include ::ActiveRecordExtensions::ValidationReflection
+  ::ActiveRecordExtensions::ValidationReflection.load_config
+  ::ActiveRecordExtensions::ValidationReflection.install(self)
+end

data/lib/vendor/plugins/validation_reflection/rails/init.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'validation_reflection'

data/lib/vendor/plugins/validation_reflection/test/test_helper.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+ENV['RAILS_ENV'] = 'test'
+RAILS_ROOT = File.join(File.dirname(__FILE__))
+
+require 'rubygems'
+
+begin
+  require 'active_record'
+rescue LoadError
+  gem 'activerecord', '>= 1.2.3'
+  require 'active_record'
+end
+
+begin
+  require 'test/unit'
+rescue LoadError
+  gem 'test-unit', '>= 1.2.3'
+  require 'test/unit'
+end

data/lib/vendor/plugins/validation_reflection/test/validation_reflection_test.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+ActiveRecord::Base.class_eval do
+  def self.validates_something_weird(*cols)
+    cols.each do |col|
+      validates_format_of col, :with => /weird/
+    end
+  end
+  def self.validates_something_selfcontained(*cols)
+    cols.each do |col|
+      validates_format_of col, :with => /blablabla/
+    end
+  end
+end
+
+require 'validation_reflection'
+
+ActiveRecord::Base.class_eval do
+  include ::ActiveRecordExtensions::ValidationReflection
+  ::ActiveRecordExtensions::ValidationReflection.reflected_validations << :validates_something_weird
+  ::ActiveRecordExtensions::ValidationReflection.reflected_validations << {
+      :method => :validates_something_selfcontained,
+      :ignore_subvalidations => true
+    }
+  ::ActiveRecordExtensions::ValidationReflection.install(self)
+end
+
+
+class ValidationReflectionTest < Test::Unit::TestCase
+
+  class Dummy < ActiveRecord::Base
+    class << self
+
+      def create_fake_column(name, null = true, limit = nil)
+        sql_type = limit ? "varchar (#{limit})" : nil
+        col = ActiveRecord::ConnectionAdapters::Column.new(name, nil, sql_type, null)
+        col
+      end
+
+      def columns
+        [
+         create_fake_column('col0'),
+         create_fake_column('col1'),
+         create_fake_column('col2', false, 100),
+         create_fake_column('col3'),
+         create_fake_column('col4'),
+         create_fake_column('col5'),
+         create_fake_column('col6'),
+         create_fake_column('col7')
+        ]
+      end
+    end
+
+    has_one :nothing
+
+    validates_presence_of :col1
+    validates_length_of :col2, :maximum => 100
+    validates_format_of :col3, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+    validates_numericality_of :col4, :only_integer => true
+    validates_numericality_of :col5, :less_than => 5
+    validates_something_weird :col6
+    validates_something_selfcontained :col7
+  end
+
+  def test_sanity
+    assert_equal [], Dummy.reflect_on_validations_for(:col0)
+  end
+
+  def test_validates_presence_of_is_reflected
+    reflections = Dummy.reflect_on_validations_for(:col1)
+    assert reflections.all? { |r| r.name.to_s == 'col1' }
+    assert reflections.find { |r| r.macro == :validates_presence_of }
+  end
+
+  def test_string_limit_is_reflected
+    reflections = Dummy.reflect_on_validations_for(:col2)
+    assert reflections.any? { |r| r.macro == :validates_length_of && r.options[:maximum] == 100 }
+  end
+
+  def test_format_is_reflected
+    reflections = Dummy.reflect_on_validations_for(:col3)
+    assert reflections.any? { |r| r.macro == :validates_format_of && r.options[:with] == /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i }
+  end
+
+  def test_numeric_integer_is_reflected
+    reflections = Dummy.reflect_on_validations_for(:col4)
+    assert reflections.any? { |r| r.macro == :validates_numericality_of && r.options[:only_integer] }
+  end
+
+  def test_numeric_is_reflected
+    reflections = Dummy.reflect_on_validations_for(:col5)
+    assert reflections.any? { |r| r.macro == :validates_numericality_of }
+  end
+
+  def test_validation_options_are_reflected
+    reflections = Dummy.reflect_on_validations_for(:col5)
+    refl = reflections[0]
+    assert_equal 5, refl.options[:less_than]
+  end
+
+  def test_custom_validations_are_reflected
+    reflections = Dummy.reflect_on_validations_for(:col6)
+    assert reflections.any? { |r| r.macro == :validates_something_weird }
+    assert reflections.any? { |r| r.macro == :validates_format_of }
+  end
+
+  def test_custom_validations_with_options_are_reflected
+    reflections = Dummy.reflect_on_validations_for(:col7)
+    assert reflections.any? { |r| r.macro == :validates_something_selfcontained }
+  end
+
+  def test_subvalidations_are_reflected
+    reflections = Dummy.reflect_on_validations_for(:col6)
+    assert_equal 2, reflections.size
+  end
+
+  def test_ignored_subvalidations_are_not_reflected
+    reflections = Dummy.reflect_on_validations_for(:col7)
+    assert_equal 1, reflections.size
+  end
+
+end

data/lib/vendor/plugins/validation_reflection/validation_reflection.gemspec

@@ -0,0 +1,52 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{validation_reflection}
+  s.version = "0.3.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Christopher Redinger"]
+  s.date = %q{2009-10-09}
+  s.description = %q{Adds reflective access to validations}
+  s.email = %q{redinger@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG",
+     "LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION.yml",
+     "about.yml",
+     "lib/validation_reflection.rb",
+     "rails/init.rb",
+     "test/test_helper.rb",
+     "test/validation_reflection_test.rb",
+     "validation_reflection.gemspec"
+  ]
+  s.homepage = %q{http://github.com/redinger/validation_reflection}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Adds reflective access to validations}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/validation_reflection_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end