gem_repackager 0.1.0

data/support/gems/rspec-rails-2.11.0/features/controller_specs/render_views.feature

@@ -0,0 +1,114 @@
+Feature: render_views
+
+  You can tell a controller example group to render views with the
+  `render_views` declaration in any individual group, or globally.
+
+  Scenario: render_views directly in a single group
+    Given a file named "spec/controllers/widgets_controller_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe WidgetsController do
+        render_views
+
+        describe "GET index" do
+          it "says 'Listing widgets'" do
+            get :index
+            response.body.should =~ /Listing widgets/m
+          end
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: render_views on and off in nested groups
+    Given a file named "spec/controllers/widgets_controller_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe WidgetsController do
+        context "with render_views" do
+          render_views
+
+          describe "GET index" do
+            it "renders the actual template" do
+              get :index
+              response.body.should =~ /Listing widgets/m
+            end
+          end
+
+          context "with render_views(false) nested in a group with render_views" do
+            render_views false
+
+            describe "GET index" do
+              it "renders the RSpec generated template" do
+                get :index
+                response.body.should eq("")
+              end
+            end
+          end
+        end
+
+        context "without render_views" do
+          describe "GET index" do
+            it "renders the RSpec generated template" do
+              get :index
+              response.body.should eq("")
+            end
+          end
+        end
+
+        context "with render_views again" do
+          render_views
+
+          describe "GET index" do
+            it "renders the actual template" do
+              get :index
+              response.body.should =~ /Listing widgets/m
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec spec --order default --format documentation`
+    Then the output should contain:
+      """
+      WidgetsController
+        with render_views
+          GET index
+            renders the actual template
+          with render_views(false) nested in a group with render_views
+            GET index
+              renders the RSpec generated template
+        without render_views
+          GET index
+            renders the RSpec generated template
+        with render_views again
+          GET index
+            renders the actual template
+      """
+
+  Scenario: render_views globally
+    Given a file named "spec/support/render_views.rb" with:
+      """
+      RSpec.configure do |config|
+        config.render_views
+      end
+      """
+    And a file named "spec/controllers/widgets_controller_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe WidgetsController do
+        describe "GET index" do
+          it "renders the index template" do
+            get :index
+            response.body.should =~ /Listing widgets/m
+          end
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass
+    

data/support/gems/rspec-rails-2.11.0/features/helper_specs/helper_spec.feature

@@ -0,0 +1,96 @@
+Feature: helper spec
+
+  Helper specs live in `spec/helpers`, or any example group with `:type =>
+  :helper`.
+
+  Helper specs expose a `helper` object, which includes the helper module being
+  specified, the `ApplicationHelper` module (if there is one) and all of the
+  helpers built into Rails. It does not include the other helper modules in
+  your app.
+
+  To access the helper methods you're specifying, simply call them directly
+  on the `helper` object.
+
+  NOTE: helper methods defined in controllers are not included.
+
+  Scenario: helper method that returns a value
+    Given a file named "spec/helpers/application_helper_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe ApplicationHelper do
+        describe "#page_title" do
+          it "returns the default title" do
+            helper.page_title.should eq("RSpec is your friend")
+          end
+        end
+      end
+      """
+    And a file named "app/helpers/application_helper.rb" with:
+      """
+      module ApplicationHelper
+        def page_title
+          "RSpec is your friend"
+        end
+      end
+      """
+    When I run `rspec spec/helpers/application_helper_spec.rb`
+    Then the examples should all pass
+
+  Scenario: helper method that accesses an instance variable
+    Given a file named "spec/helpers/application_helper_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe ApplicationHelper do
+        describe "#page_title" do
+          it "returns the instance variable" do
+            assign(:title, "My Title")
+            helper.page_title.should eql("My Title")
+          end
+        end
+      end
+      """
+    And a file named "app/helpers/application_helper.rb" with:
+      """
+      module ApplicationHelper
+        def page_title
+          @title || nil
+        end
+      end
+      """
+    When I run `rspec spec/helpers/application_helper_spec.rb`
+    Then the examples should all pass
+
+  Scenario: application helper is included in helper object
+    Given a file named "spec/helpers/widgets_helper_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe WidgetsHelper do
+        describe "#widget_title" do
+          it "includes the app name" do
+            assign(:title, "This Widget")
+            helper.widget_title.should eq("The App: This Widget")
+          end
+        end
+      end
+      """
+    And a file named "app/helpers/application_helper.rb" with:
+      """
+      module ApplicationHelper
+        def app_name
+          "The App"
+        end
+      end
+      """
+    And a file named "app/helpers/widgets_helper.rb" with:
+      """
+      module WidgetsHelper
+        def widget_title
+          "#{app_name}: #{@title}"
+        end
+      end
+      """
+    When I run `rspec spec/helpers/widgets_helper_spec.rb`
+    Then the examples should all pass

data/support/gems/rspec-rails-2.11.0/features/mailer_specs/url_helpers.feature

@@ -0,0 +1,38 @@
+Feature: URL helpers in mailer examples
+
+  Scenario: using URL helpers with default options
+    Given a file named "config/initializers/mailer_defaults.rb" with:
+      """
+      Rails.configuration.action_mailer.default_url_options = { :host => 'example.com' }
+      """
+    And a file named "spec/mailers/notifications_spec.rb" with:
+      """
+      require 'spec_helper'
+
+      describe Notifications do
+        it 'should have access to URL helpers' do
+          lambda { gadgets_url }.should_not raise_error
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: using URL helpers without default options
+    Given a file named "config/initializers/mailer_defaults.rb" with:
+      """
+      # no default options
+      """
+    And a file named "spec/mailers/notifications_spec.rb" with:
+      """
+      require 'spec_helper'
+
+      describe Notifications do
+        it 'should have access to URL helpers' do
+          lambda { gadgets_url :host => 'example.com' }.should_not raise_error
+          lambda { gadgets_url }.should raise_error
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass

data/support/gems/rspec-rails-2.11.0/features/matchers/README.md

@@ -0,0 +1,18 @@
+rspec-rails offers a number of custom matchers, most of which are
+rspec-compatible wrappers for Rails' assertions.
+
+### redirects
+
+    # delegates to assert_redirected_to
+    response.should redirect_to(path)
+
+### templates
+
+    # delegates to assert_template
+    response.should render_template(template_name)
+
+### assigned objects
+
+    # passes if assigns(:widget) is an instance of Widget
+    # and it is not persisted
+    assigns(:widget).should be_a_new(Widget)

data/support/gems/rspec-rails-2.11.0/features/matchers/new_record_matcher.feature

@@ -0,0 +1,28 @@
+Feature: be_a_new matcher
+
+  The `be_a_new` matcher accepts a class and passes if the subject is an
+  instance of that class that returns false to persisted?
+
+  You can also chain `with` on `be_a_new` with a hash of attributes to specify
+  the subject has equal attributes.
+
+  Scenario: example spec with four be_a_new possibilities 
+    Given a file named "spec/models/widget_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe Widget do
+        context "when initialized" do
+          subject { Widget.new }
+          it { should be_a_new(Widget) }
+          it { should_not be_a_new(String) }
+        end
+        context "when saved" do
+          subject { Widget.create }
+          it { should_not be_a_new(Widget) }
+          it { should_not be_a_new(String) }
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass

data/support/gems/rspec-rails-2.11.0/features/matchers/redirect_to_matcher.feature

@@ -0,0 +1,40 @@
+Feature: redirect_to matcher
+
+  The `redirect_to` matcher is used to specify that a request redirects to a
+  given template or action.  It delegates to
+  [`assert_redirected_to`](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/ResponseAssertions.html#method-i-assert_redirected_to).
+
+  It is available in controller specs (spec/controllers) and request
+  specs (spec/requests).
+
+  Scenario: redirect_to with four possible options
+    Given a file named "spec/controllers/widgets_controller_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe WidgetsController do
+
+        describe "#create" do
+          subject { post :create, :widget => { :name => "Foo" } }
+
+          it "redirects to widget_url(@widget)" do
+            subject.should redirect_to(widget_url(assigns(:widget)))
+          end
+
+          it "redirects_to :action => :show" do
+            subject.should redirect_to :action => :show,
+                                       :id => assigns(:widget).id
+          end
+
+          it "redirects_to(@widget)" do
+            subject.should redirect_to(assigns(:widget))
+          end
+
+          it "redirects_to /widgets/:id" do
+            subject.should redirect_to("/widgets/#{assigns(:widget).id}")
+          end
+        end
+      end
+      """
+    When I run `rspec spec/controllers/widgets_controller_spec.rb`
+    Then the examples should all pass

data/support/gems/rspec-rails-2.11.0/features/matchers/relation_match_array.feature

@@ -0,0 +1,20 @@
+Feature: ActiveRecord::Relation match array
+
+  The `=~` matcher can be used with an `ActiveRecord::Relation` (scope). The
+  assertion will pass if the scope would return all of the elements specified
+  in the array on the right hand side.
+
+  Scenario: example spec with relation =~ matcher
+    Given a file named "spec/models/widget_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe Widget do
+        let!(:widgets) { Array.new(3) { Widget.create } }
+        subject { Widget.scoped }
+
+        it { should =~ widgets }
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass

data/support/gems/rspec-rails-2.11.0/features/matchers/render_template_matcher.feature

@@ -0,0 +1,28 @@
+Feature: render_template matcher
+
+  The `render_template` matcher is used to specify that a request renders a
+  given template.  It delegates to
+  [`assert_template`](http://api.rubyonrails.org/classes/ActionController/TemplateAssertions.html#method-i-assert_template)
+
+  It is available in controller specs (spec/controllers) and request
+  specs (spec/requests).
+
+  NOTE: use `redirect_to(:action => 'new')` for redirects, not `render_template`.
+
+  Scenario: render_template with three possible options
+    Given a file named "spec/controllers/gadgets_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe GadgetsController do
+        describe "GET #index" do
+          subject { get :index }
+
+          it { should render_template(:index) }
+          it { should render_template("index") }
+          it { should render_template("gadgets/index") }
+        end
+      end
+      """
+    When I run `rspec spec/controllers/gadgets_spec.rb`
+    Then the examples should all pass

data/support/gems/rspec-rails-2.11.0/features/mocks/mock_model.feature

@@ -0,0 +1,147 @@
+Feature: mock_model
+
+  The `mock_model` method generates a test double that acts like an instance of
+  `ActiveModel`. This is different from the `stub_model` method which generates
+  an instance of a real model class.
+
+  The benefit of `mock_model` over `stub_model` is that it is a true double, so
+  the examples are not dependent on the behavior (or mis-behavior), or even the
+  existence of any other code. If you're working on a controller spec and you
+  need a model that doesn't exist, you can pass `mock_model` a string and the
+  generated object will act as though its an instance of the class named by
+  that string.
+   
+  Scenario: passing a string that represents a non-existent constant
+    Given a file named "spec/models/car_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe "mock_model('Car') with no Car constant in existence" do
+        it "generates a constant" do
+          Object.const_defined?(:Car).should be_false
+          mock_model("Car")
+          Object.const_defined?(:Car).should be_true
+        end
+
+        describe "generates an object that ..." do
+          it "returns the correct name" do
+            car = mock_model("Car")
+            car.class.name.should eq("Car")
+          end
+
+          it "says it is a Car" do
+            car = mock_model("Car")
+            car.should be_a(Car)
+          end
+        end
+      end
+      """
+    When I run `rspec spec/models/car_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing a string that represents an existing constant
+    Given a file named "spec/models/widget_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe Widget do
+        it "uses the existing constant" do
+          widget = mock_model("Widget")
+          widget.should be_a(Widget)
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing a class that does not extend ActiveModel::Naming
+    Given a file named "spec/models/string_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe String do
+        it "raises" do
+          expect { mock_model(String) }.to raise_exception
+        end
+      end
+      """
+    When I run `rspec spec/models/string_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing an Active Record constant
+    Given a file named "spec/models/widget_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe Widget do
+        let(:widget) { mock_model(Widget) }
+
+        it "is valid by default" do
+          widget.should be_valid
+        end
+
+        it "is not a new record by default" do
+          widget.should_not be_new_record
+        end
+
+        it "can be converted to a new record" do
+          widget.as_new_record.should be_new_record
+        end
+
+        it "sets :id to nil upon destroy" do
+          widget.destroy
+          widget.id.should be_nil
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing an Active Record constant with method stubs
+    Given a file named "spec/models/widget_spec.rb" with:
+      """
+      require "spec_helper"
+
+      describe "mock_model(Widget) with stubs" do
+        let(:widget) do
+          mock_model Widget, :foo => "bar",
+                             :save => true,
+                             :update_attributes => false
+        end
+
+        it "supports stubs for methods that don't exist in ActiveModel or ActiveRecord" do
+          widget.foo.should eq("bar")
+        end
+
+        it "supports stubs for methods that do exist" do
+          widget.save.should eq(true)
+          widget.update_attributes.should be_false
+        end
+
+        describe "#errors" do
+          context "with update_attributes => false" do
+            it "is not empty" do
+              widget.errors.should_not be_empty
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: mock_model outside rails
+    Given a file named "mock_model_outside_rails_spec.rb" with:
+      """
+      require 'rspec/rails/mocks'
+
+      describe "Foo" do
+        it "is mockable" do
+          foo = mock_model("Foo")
+          foo.id.should eq(1001)
+          foo.to_param.should eq("1001")
+        end
+      end
+      """
+    When I run `rspec mock_model_outside_rails_spec.rb`
+    Then the examples should all pass