rails 2.2.3 → 2.3.2

data/doc/guides/source/creating_plugins/controllers.txt

@@ -1,59 +0,0 @@
-== Add a controller ==
-
-This section describes how to add a controller named 'woodpeckers' to your plugin that will behave the same as a controller in your main app.  This is very similar to adding a model.
-
-You can test your plugin's controller as you would test any other controller:
-
-*vendor/plugins/yaffle/yaffle/woodpeckers_controller_test.rb:*
-
-[source, ruby]
-----------------------------------------------
-require File.dirname(__FILE__) + '/test_helper.rb'
-require 'woodpeckers_controller'
-require 'action_controller/test_process'
-
-class WoodpeckersController; def rescue_action(e) raise e end; end
-
-class WoodpeckersControllerTest < Test::Unit::TestCase
-  def setup
-    @controller = WoodpeckersController.new
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-  end
-
-  def test_index
-    get :index
-    assert_response :success
-  end
-end
-----------------------------------------------
-
-This is just a simple test to make sure the controller is being loaded correctly.  After watching it fail with `rake`, you can make it pass like so:
-
-*vendor/plugins/yaffle/lib/yaffle.rb:*
-
-[source, ruby]
-----------------------------------------------
-%w{ models controllers }.each do |dir|
-  path = File.join(File.dirname(__FILE__), 'app', dir)
-  $LOAD_PATH << path
-  ActiveSupport::Dependencies.load_paths << path
-  ActiveSupport::Dependencies.load_once_paths.delete(path)
-end
-----------------------------------------------
-
-
-*vendor/plugins/yaffle/lib/app/controllers/woodpeckers_controller.rb:*
-
-[source, ruby]
-----------------------------------------------
-class WoodpeckersController < ActionController::Base
-  
-  def index
-    render :text => "Squawk!"
-  end
-  
-end
-----------------------------------------------
-
-Now your test should be passing, and you should be able to use the Woodpeckers controller in your app.  If you add a route for the woodpeckers controller you can start up your server and go to http://localhost:3000/woodpeckers to see your controller in action.

data/doc/guides/source/creating_plugins/core_ext.txt

@@ -1,123 +0,0 @@
-== Extending core classes ==
-
-This section will explain how to add a method to String that will be available anywhere in your rails app by:
-
- * Writing tests for the desired behavior
- * Creating and requiring the correct files
-
-=== Creating the test ===
-
-In this example you will add a method to String named `to_squawk`.  To begin, create a new test file with a few assertions:
-
-*vendor/plugins/yaffle/test/core_ext_test.rb*
-
-[source, ruby]
---------------------------------------------------------
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class CoreExtTest < Test::Unit::TestCase
-  def test_to_squawk_prepends_the_word_squawk
-    assert_equal "squawk! Hello World", "Hello World".to_squawk
-  end
-end
---------------------------------------------------------
-
-Navigate to your plugin directory and run `rake test`:
-
---------------------------------------------------------
-cd vendor/plugins/yaffle
-rake test
---------------------------------------------------------
-
-The test above should fail with the message:
-
---------------------------------------------------------
- 1) Error:
-test_to_squawk_prepends_the_word_squawk(CoreExtTest):
-NoMethodError: undefined method `to_squawk' for "Hello World":String
-    ./test/core_ext_test.rb:5:in `test_to_squawk_prepends_the_word_squawk'
---------------------------------------------------------
-
-Great - now you are ready to start development.
-
-=== Organize your files ===
-
-A common pattern in rails plugins is to set up the file structure like this:
-
---------------------------------------------------------
-|-- lib
-|   |-- yaffle
-|   |   `-- core_ext.rb
-|   `-- yaffle.rb
---------------------------------------------------------
-
-The first thing we need to to is to require our 'lib/yaffle.rb' file from 'rails/init.rb':
-
-*vendor/plugins/yaffle/rails/init.rb*
-
-[source, ruby]
---------------------------------------------------------
-require 'yaffle'
---------------------------------------------------------
-
-Then in 'lib/yaffle.rb' require 'lib/core_ext.rb':
-
-*vendor/plugins/yaffle/lib/yaffle.rb*
-
-[source, ruby]
---------------------------------------------------------
-require "yaffle/core_ext"
---------------------------------------------------------
-
-Finally, create the 'core_ext.rb' file and add the 'to_squawk' method:
-
-*vendor/plugins/yaffle/lib/yaffle/core_ext.rb*
-
-[source, ruby]
---------------------------------------------------------
-String.class_eval do
-  def to_squawk
-    "squawk! #{self}".strip
-  end
-end
---------------------------------------------------------
-
-To test that your method does what it says it does, run the unit tests with `rake` from your plugin directory.  To see this in action, fire up a console and start squawking:
-
---------------------------------------------------------
-$ ./script/console
->> "Hello World".to_squawk
-=> "squawk! Hello World"
---------------------------------------------------------
-
-=== Working with init.rb ===
-
-When rails loads plugins it looks for the file named init.rb.  However, when the plugin is initialized, 'init.rb' is invoked via `eval` (not `require`) so it has slightly different behavior.
-
-Under certain circumstances if you reopen classes or modules in 'init.rb' you may inadvertently create a new class, rather than reopening an existing class.  A better alternative is to reopen the class in a different file, and require that file from `init.rb`, as shown above.
-
-If you must reopen a class in `init.rb` you can use `module_eval` or `class_eval` to avoid any issues:
-
-*vendor/plugins/yaffle/init.rb*
-
-[source, ruby]
----------------------------------------------------
-Hash.class_eval do
-  def is_a_special_hash?
-    true
-  end
-end
----------------------------------------------------
-
-Another way is to explicitly define the top-level module space for all modules and classes, like `::Hash`:
-
-*vendor/plugins/yaffle/init.rb*
-
-[source, ruby]
----------------------------------------------------
-class ::Hash
-  def is_a_special_hash?
-    true
-  end
-end
----------------------------------------------------

data/doc/guides/source/creating_plugins/custom_route.txt

@@ -1,69 +0,0 @@
-== Add a Custom Route ==
-
-Testing routes in plugins can be complex, especially if the controllers are also in the plugin itself.  Jamis Buck showed a great example of this in http://weblog.jamisbuck.org/2006/10/26/monkey-patching-rails-extending-routes-2.
-
-*vendor/plugins/yaffle/test/routing_test.rb*
-
-[source, ruby]
---------------------------------------------------------
-require "#{File.dirname(__FILE__)}/test_helper"
-
-class RoutingTest < Test::Unit::TestCase
-
-  def setup
-    ActionController::Routing::Routes.draw do |map|
-      map.yaffles
-    end
-  end
-
-  def test_yaffles_route
-    assert_recognition :get, "/yaffles", :controller => "yaffles_controller", :action => "index"
-  end
-
-  private
-
-    # yes, I know about assert_recognizes, but it has proven problematic to
-    # use in these tests, since it uses RouteSet#recognize (which actually
-    # tries to instantiate the controller) and because it uses an awkward
-    # parameter order.
-    def assert_recognition(method, path, options)
-      result = ActionController::Routing::Routes.recognize_path(path, :method => method)
-      assert_equal options, result
-    end
-end
---------------------------------------------------------
-
-*vendor/plugins/yaffle/init.rb*
-
-[source, ruby]
---------------------------------------------------------
-require "routing"
-ActionController::Routing::RouteSet::Mapper.send :include, Yaffle::Routing::MapperExtensions
---------------------------------------------------------
-
-*vendor/plugins/yaffle/lib/routing.rb*
-
-[source, ruby]
---------------------------------------------------------
-module Yaffle #:nodoc:
-  module Routing #:nodoc:
-    module MapperExtensions
-      def yaffles
-        @set.add_route("/yaffles", {:controller => "yaffles_controller", :action => "index"})
-      end
-    end
-  end
-end
---------------------------------------------------------
-
-*config/routes.rb*
-
-[source, ruby]
---------------------------------------------------------
-ActionController::Routing::Routes.draw do |map|
-  ...
-  map.yaffles
-end
---------------------------------------------------------
-
-You can also see if your routes work by running `rake routes` from your app directory.

data/doc/guides/source/creating_plugins/gem.txt

@@ -1 +0,0 @@
-http://www.mbleigh.com/2008/6/11/gemplugins-a-brief-introduction-to-the-future-of-rails-plugins

data/doc/guides/source/creating_plugins/generator_method.txt

@@ -1,89 +0,0 @@
-== Add a custom generator command ==
-
-You may have noticed above that you can used one of the built-in rails migration commands `migration_template`.  If your plugin needs to add and remove lines of text from existing files you will need to write your own generator methods.
-
-This section describes how you you can create your own commands to add and remove a line of text from 'routes.rb'.  This example creates a very simple method that adds or removes a text file.
-
-To start, add the following test method:
-
-*vendor/plugins/yaffle/test/generator_test.rb*
-
-[source, ruby]
------------------------------------------------------------
-def test_generates_definition
-  Rails::Generator::Scripts::Generate.new.run(["yaffle", "bird"], :destination => fake_rails_root)
-  definition = File.read(File.join(fake_rails_root, "definition.txt"))
-  assert_match /Yaffle\:/, definition
-end
------------------------------------------------------------
-
-Run `rake` to watch the test fail, then make the test pass add the following:
-
-*vendor/plugins/yaffle/generators/yaffle/templates/definition.txt*
-
------------------------------------------------------------
-Yaffle: A bird
------------------------------------------------------------
-
-*vendor/plugins/yaffle/lib/yaffle.rb*
-
-[source, ruby]
------------------------------------------------------------
-require "yaffle/commands"
------------------------------------------------------------
-
-*vendor/plugins/yaffle/lib/commands.rb*
-
-[source, ruby]
------------------------------------------------------------
-require 'rails_generator'
-require 'rails_generator/commands'
-
-module Yaffle #:nodoc:
-  module Generator #:nodoc:
-    module Commands #:nodoc:
-      module Create
-        def yaffle_definition
-          file("definition.txt", "definition.txt")
-        end
-      end
-
-      module Destroy
-        def yaffle_definition
-          file("definition.txt", "definition.txt")
-        end
-      end
-
-      module List
-        def yaffle_definition
-          file("definition.txt", "definition.txt")
-        end
-      end
-
-      module Update
-        def yaffle_definition
-          file("definition.txt", "definition.txt")
-        end
-      end
-    end
-  end
-end
-
-Rails::Generator::Commands::Create.send   :include,  Yaffle::Generator::Commands::Create
-Rails::Generator::Commands::Destroy.send  :include,  Yaffle::Generator::Commands::Destroy
-Rails::Generator::Commands::List.send     :include,  Yaffle::Generator::Commands::List
-Rails::Generator::Commands::Update.send   :include,  Yaffle::Generator::Commands::Update
------------------------------------------------------------
-
-Finally, call your new method in the manifest:
-
-*vendor/plugins/yaffle/generators/yaffle/yaffle_generator.rb*
-
-[source, ruby]
------------------------------------------------------------
-class YaffleGenerator < Rails::Generator::NamedBase
-  def manifest
-    m.yaffle_definition
-  end
-end
------------------------------------------------------------

data/doc/guides/source/creating_plugins/helpers.txt

@@ -1,51 +0,0 @@
-== Add a helper ==
-
-This section describes how to add a helper named 'WoodpeckersHelper' to your plugin that will behave the same as a helper in your main app.  This is very similar to adding a model and a controller.
-
-You can test your plugin's helper as you would test any other helper:
-
-*vendor/plugins/yaffle/test/woodpeckers_helper_test.rb*
-
-[source, ruby]
----------------------------------------------------------------
-require File.dirname(__FILE__) + '/test_helper.rb'
-include WoodpeckersHelper
-
-class WoodpeckersHelperTest < Test::Unit::TestCase
-  def test_tweet
-    assert_equal "Tweet! Hello", tweet("Hello")
-  end
-end
----------------------------------------------------------------
-
-This is just a simple test to make sure the helper is being loaded correctly.  After watching it fail with `rake`, you can make it pass like so:
-
-*vendor/plugins/yaffle/lib/yaffle.rb:*
-
-[source, ruby]
-----------------------------------------------
-%w{ models controllers helpers }.each do |dir|
-  path = File.join(File.dirname(__FILE__), 'app', dir)
-  $LOAD_PATH << path
-  ActiveSupport::Dependencies.load_paths << path
-  ActiveSupport::Dependencies.load_once_paths.delete(path)
-end
-
-ActionView::Base.send :include, WoodpeckersHelper
-----------------------------------------------
-
-
-*vendor/plugins/yaffle/lib/app/helpers/woodpeckers_helper.rb:*
-
-[source, ruby]
-----------------------------------------------
-module WoodpeckersHelper
-  
-  def tweet(text)
-    "Tweet! #{text}"
-  end
-  
-end
-----------------------------------------------
-
-Now your test should be passing, and you should be able to use the Woodpeckers helper in your app.

data/doc/guides/source/creating_plugins/index.txt

@@ -1,52 +0,0 @@
-The Basics of Creating Rails Plugins
-====================================
-
-A Rails plugin is either an extension or a modification of the core framework. Plugins provide:
-
- * a way for developers to share bleeding-edge ideas without hurting the stable code base
- * a segmented architecture so that units of code can be fixed or updated on their own release schedule
- * an outlet for the core developers so that they don’t have to include every cool new feature under the sun
-
-After reading this guide you should be familiar with:
- 
- * Creating a plugin from scratch
- * Writing and running tests for the plugin
- * Storing models, views, controllers, helpers and even other plugins in your plugins
- * Writing generators
- * Writing custom Rake tasks in your plugin
- * Generating RDoc documentation for your plugin
- * Avoiding common pitfalls with 'init.rb'
-
-This guide describes how to build a test-driven plugin that will:
-
- * Extend core ruby classes like Hash and String
- * Add methods to ActiveRecord::Base in the tradition of the 'acts_as' plugins
- * Add a view helper that can be used in erb templates
- * Add a new generator that will generate a migration
- * Add a custom generator command
- * A custom route method that can be used in routes.rb
-
-For the purpose of this guide pretend for a moment that you are an avid bird watcher.  Your favorite bird is the Yaffle, and you want to create a plugin that allows other developers to share in the Yaffle goodness.  First, you need to get setup for development.
-
-
-include::test_setup.txt[]
-
-include::core_ext.txt[]
-
-include::acts_as_yaffle.txt[]
-
-include::migration_generator.txt[]
-
-include::generator_method.txt[]
-
-include::models.txt[]
-
-include::controllers.txt[]
-
-include::helpers.txt[]
-
-include::custom_route.txt[]
-
-include::odds_and_ends.txt[]
-
-include::appendix.txt[]