rails_inheritable_attributes_manager 0.3.0

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+group :test do
+  gem "shoulda"
+  gem "redgreen"
+  gem "actionpack", "2.3.8"
+  gem "activerecord", "2.3.8"
+  gem "sqlite3-ruby"
+end
+
+group :development do
+  gem "rake"
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009,2010 Ryan L. Bell
+
+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/README.markdown

@@ -0,0 +1,33 @@
+# Inheritable Attributes Manager for Rails
+
+Inheritable Attributes Manager makes sure that those magic rails bits (filters, nestested associations, etc.) make it into your subclasses, regardless of the order the code is loaded.
+
+## Install
+
+As a plugin:
+
+    ./script/plugin install git://github.com/kofno/rails_inheritable_attributes_manager.git
+
+As a gem:
+
+    gem install rails_inheritable_attributes_manager
+
+And don't forget to add the gem to your rails config
+
+    config.gem "rails_inheritable_attributes_manager"
+
+## Links
+
+* [Wiki](http://wiki.github.com/kofno/rails_inheritable_attributes_manager)
+* [Issues](http://github.com/kofno/rails_inheritable_attributes_manager/issues)
+
+## Why would I need this?
+
+You may not. In general, the Rails community tends to treat plugins as extensions to Rails, and application code builds on Rails and the plugins. For this scenario, the default inheritable attributes behavior is fine.
+
+Of course, the other use of plugins is to extend the application's functionality. When writing an extension, its quite common to re-open the application classes (controllers, STI models, etc.) and add filters or associations. In this scenario, depending on how the code loads, subclasses may not receive the new functionality. This is exactly the scenario inheritable attributes manager was created to fix.
+
+[More information on inheritable attributes and filter chains](http://wiki.github.com/kofno/rails_inheritable_attributes_manager/rails-inheritable-attributes)
+
+[How it works](http://wiki.github.com/kofno/rails_inheritable_attributes_manager/how-it-works)
+

data/RELEASE_NOTES

@@ -0,0 +1,8 @@
+* 0.3.0 *
+Support for inherited nested attributes
+
+* 0.2.0 * (never released)
+Name change
+
+* 0.1.0 *
+Support for controller filter chains

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs = %w(tests lib)
+  t.pattern = 'tests/**/*_test.rb'
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/init.rb

@@ -0,0 +1 @@
+require 'rails_inheritable_attributes_manager'

data/lib/controllers/controller_filters.rb

@@ -0,0 +1,57 @@
+require 'action_controller'
+
+module ActionController
+
+  class Base
+    class << self
+      def self.record_filter_chain_ops_for(*filter_methods)
+        filter_methods.each do |meth|
+          class_eval <<-CODE
+            def #{meth}_with_recording(*filters, &block)
+              filter_operation = lambda { #{meth}_without_recording(*filters, &block) }
+              filter_operation.call
+              recorded_filter_chain_ops << filter_operation
+              refresh_subclass_filter_chains
+            end
+            alias_method_chain meth, :recording
+          CODE
+        end
+      end
+      record_filter_chain_ops_for :append_before_filter, :before_filter
+      record_filter_chain_ops_for :append_after_filter,  :after_filter
+      record_filter_chain_ops_for :append_around_filter, :around_filter
+      record_filter_chain_ops_for :prepend_before_filter, :prepend_after_filter, :prepend_around_filter
+      record_filter_chain_ops_for :skip_before_filter, :skip_after_filter, :skip_filter
+
+      def refresh_subclass_filter_chains
+        immediate_subclasses.each do |child|
+          child.write_inheritable_attribute('filter_chain', filter_chain.dup)
+          child.replay_filter_chain_ops
+          child.refresh_subclass_filter_chains
+        end
+      end
+
+      def replay_filter_chain_ops
+        recorded_filter_chain_ops.each { |filter_chain_op| filter_chain_op.call }
+      end
+
+      def immediate_subclasses
+        @immediate_subclasses ||= []
+      end
+
+      def inherited_with_subclass_recording(child)
+        immediate_subclasses << child
+        inherited_without_subclass_recording(child)
+      end
+      alias_method_chain :inherited, :subclass_recording
+
+      def recorded_filter_chain_ops
+        @recorded_filter_chain_ops ||= []
+      end
+
+    end
+
+  end
+
+end
+

data/lib/models/nested_attributes.rb

@@ -0,0 +1,27 @@
+require 'active_record'
+
+module ActiveRecord
+
+  class Base
+    class << self
+      def accepts_nested_attributes_for_with_inheritance_management(*attr_names)
+        accepts_nested_attributes_for_without_inheritance_management(*attr_names)
+        alert_subclasses_of_new_nested_attributes
+      end
+      alias_method_chain :accepts_nested_attributes_for, :inheritance_management
+
+      def alert_subclasses_of_new_nested_attributes
+        subclasses.each do |subclass|
+          subclass.superclass_received_nested_attributes(nested_attributes_options)
+        end
+      end
+
+      def superclass_received_nested_attributes(super_nested_attr_options)
+        nested_attributes_options.update(super_nested_attr_options) do |hash, oldval, newval|
+          oldval.nil? ? newval : oldval
+        end
+      end
+    end
+  end
+
+end

data/lib/rails_inheritable_attributes_manager.rb

@@ -0,0 +1,2 @@
+require 'controllers/controller_filters'
+require 'models/nested_attributes'

data/tests/controllers/append_after_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class AfterFiltersTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    after_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    after_filter :child_filter
+  end
+
+  ApplicationController.class_eval do
+    after_filter :after_thought
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_contains_filter @app_filter_chain, :application_filter
+      assert_contains_filter @app_filter_chain, :after_thought
+      assert_equal 2, @app_filter_chain.size
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_contains_filter @child_filter_chain, :application_filter
+      assert_contains_filter @child_filter_chain, :after_thought
+      assert_contains_filter @child_filter_chain, :child_filter
+      assert_equal 3, @child_filter_chain.size
+    end
+  end
+end

data/tests/controllers/append_around_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class AppendAroundTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    around_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    around_filter :child_filter
+  end
+
+  ApplicationController.class_eval do
+    around_filter :after_thought
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_contains_filter @app_filter_chain, :application_filter
+      assert_contains_filter @app_filter_chain, :after_thought
+      assert_equal 2, @app_filter_chain.size
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_contains_filter @child_filter_chain, :application_filter
+      assert_contains_filter @child_filter_chain, :after_thought
+      assert_contains_filter @child_filter_chain, :child_filter
+      assert_equal 3, @child_filter_chain.size
+    end
+  end
+end

data/tests/controllers/append_before_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class ReopenParentControllerFilterChainTest < Test::Unit::TestCase
+  # build our test classes
+  class ApplicationController < ::ActionController::Base
+    before_filter :application_filter
+    def application_filter; puts "something"; end
+  end
+
+  class ChildController < ApplicationController
+    before_filter :child_filter
+    def child_filter; puts "from the mouths of babes";end
+  end
+
+  # now we reload
+  ApplicationController.class_eval do
+    before_filter :new_stuff_baby
+    def new_stuff_baby; puts "yeah!"; end
+  end
+
+  def app_filter_chain
+    ApplicationController.filter_chain
+  end
+
+  def child_filter_chain
+    ChildController.filter_chain
+  end
+
+  context "The ApplicationController" do
+
+    should "have a two filters" do
+      assert_equal 2, app_filter_chain.size
+    end
+
+    should "have a filter named :new_stuff_baby" do
+      assert_contains_filter app_filter_chain, :new_stuff_baby
+    end
+
+  end
+
+  context "The ChildController" do
+
+    should "have a three filters" do
+      assert_equal 3, child_filter_chain.size
+    end
+
+    should "have a filter named :new_stuff_baby" do
+      assert_contains_filter child_filter_chain, :new_stuff_baby
+    end
+
+  end
+
+end

data/tests/controllers/deep_class_hierarchy_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class DeepClassHierarchyTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    after_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    before_filter :child_filter
+    skip_filter :after_thought
+  end
+
+  ApplicationController.class_eval do
+    around_filter :after_thought
+    before_filter { puts "poo" }
+  end
+
+  class SubChildController < ChildController
+    append_before_filter :sub_filter
+    skip_after_filter :application_filter
+  end
+
+  ChildController.class_eval do
+    append_after_filter :late_arrival
+    append_around_filter :gets_around
+    prepend_before_filter :line_cutter
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_chain_order [:after_thought, :a_proc, :application_filter], @app_filter_chain
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_chain_order [:line_cutter, :a_proc, :child_filter, :gets_around, :application_filter, :late_arrival], @child_filter_chain
+    end
+  end
+
+  context "The SubChildController" do
+    setup do
+      @sub_child_filter_chain = SubChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_chain_order [:line_cutter, :a_proc, :child_filter, :gets_around, :sub_filter, :late_arrival], @sub_child_filter_chain
+    end
+  end
+
+end

data/tests/controllers/normal_filter_chain_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+# captures normal, healthy filter_chain behavior
+class NormalFilterChainTest < Test::Unit::TestCase
+
+  # build our test classes
+  class ApplicationController < ::ActionController::Base
+    before_filter :application_filter
+    def application_filter; puts "something"; end
+  end
+
+  class ChildController < ApplicationController
+    before_filter :child_filter
+    def child_filter; puts "from the mouths of babes";end
+  end
+
+  def app_filter_chain
+    ApplicationController.filter_chain
+  end
+
+  def child_filter_chain
+    ChildController.filter_chain
+  end
+
+  context "The ApplicationController" do
+
+    should "inherited filters be the same" do
+      assert_equal app_filter_chain.first, child_filter_chain.first
+    end
+
+    should 'have one filter' do
+      assert_equal 1, app_filter_chain.size
+    end
+
+    should 'have a filter named :application_filter' do
+      assert_contains_filter app_filter_chain, :application_filter
+    end
+  end
+
+  context "The ChildController" do
+
+    should 'have two filters' do
+      assert_equal 2, child_filter_chain.size
+    end
+
+    should 'have a filter named :application_filter' do
+      assert_contains_filter child_filter_chain, :application_filter
+    end
+
+    should 'have a filter named :child_filter' do
+      assert_contains_filter child_filter_chain, :child_filter
+    end
+
+  end
+
+end

data/tests/controllers/prepend_after_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class PrependAfterTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    prepend_after_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    prepend_after_filter :child_filter
+  end
+
+  ApplicationController.class_eval do
+    prepend_after_filter :after_thought
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_contains_filter @app_filter_chain, :application_filter
+      assert_contains_filter @app_filter_chain, :after_thought
+      assert_equal 2, @app_filter_chain.size
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_contains_filter @child_filter_chain, :application_filter
+      assert_contains_filter @child_filter_chain, :after_thought
+      assert_contains_filter @child_filter_chain, :child_filter
+      assert_equal 3, @child_filter_chain.size
+    end
+  end
+end

data/tests/controllers/prepend_around_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class PrependAroundTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    prepend_around_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    prepend_around_filter :child_filter
+  end
+
+  ApplicationController.class_eval do
+    prepend_around_filter :after_thought
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_contains_filter @app_filter_chain, :application_filter
+      assert_contains_filter @app_filter_chain, :after_thought
+      assert_equal 2, @app_filter_chain.size
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_contains_filter @child_filter_chain, :application_filter
+      assert_contains_filter @child_filter_chain, :after_thought
+      assert_contains_filter @child_filter_chain, :child_filter
+      assert_equal 3, @child_filter_chain.size
+    end
+  end
+end

data/tests/controllers/prepend_before_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class PrependBeforeTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    prepend_before_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    prepend_before_filter :child_filter
+  end
+
+  ApplicationController.class_eval do
+    prepend_before_filter :after_thought
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_contains_filter @app_filter_chain, :application_filter
+      assert_contains_filter @app_filter_chain, :after_thought
+      assert_equal 2, @app_filter_chain.size
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_contains_filter @child_filter_chain, :application_filter
+      assert_contains_filter @child_filter_chain, :after_thought
+      assert_contains_filter @child_filter_chain, :child_filter
+      assert_equal 3, @child_filter_chain.size
+    end
+  end
+end

data/tests/controllers/skip_after_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class SkipAfterTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    after_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    after_filter :child_filter
+    skip_after_filter :after_thought
+  end
+
+  ApplicationController.class_eval do
+    after_filter :after_thought
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_contains_filter @app_filter_chain, :application_filter
+      assert_contains_filter @app_filter_chain, :after_thought
+      assert_equal 2, @app_filter_chain.size
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_contains_filter @child_filter_chain, :application_filter
+      assert_filter_absent   @child_filter_chain, :after_thought
+      assert_contains_filter @child_filter_chain, :child_filter
+      assert_equal 2, @child_filter_chain.size
+    end
+  end
+end

data/tests/controllers/skip_before_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class SkipBeforeTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    before_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    before_filter :child_filter
+    skip_before_filter :after_thought
+  end
+
+  ApplicationController.class_eval do
+    before_filter :after_thought
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_contains_filter @app_filter_chain, :application_filter
+      assert_contains_filter @app_filter_chain, :after_thought
+      assert_equal 2, @app_filter_chain.size
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_contains_filter @child_filter_chain, :application_filter
+      assert_filter_absent   @child_filter_chain, :after_thought
+      assert_contains_filter @child_filter_chain, :child_filter
+      assert_equal 2, @child_filter_chain.size
+    end
+  end
+end

data/tests/controllers/skip_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class SkipTest < Test::Unit::TestCase
+
+  class ApplicationController < ::ActionController::Base
+    after_filter :application_filter
+  end
+
+  class ChildController < ApplicationController
+    before_filter :child_filter
+    skip_filter :after_thought
+  end
+
+  ApplicationController.class_eval do
+    around_filter :after_thought
+  end
+
+  context "The ApplicationController" do
+    setup do
+      @app_filter_chain = ApplicationController.filter_chain
+    end
+
+    should "have only its own filters" do
+      assert_contains_filter @app_filter_chain, :application_filter
+      assert_contains_filter @app_filter_chain, :after_thought
+      assert_equal 2, @app_filter_chain.size
+    end
+
+  end
+
+  context "The ChildController" do
+    setup do
+      @child_filter_chain = ChildController.filter_chain
+    end
+
+    should "should have its own filter, plus the inherited ones" do
+      assert_contains_filter @child_filter_chain, :application_filter
+      assert_filter_absent   @child_filter_chain, :after_thought
+      assert_contains_filter @child_filter_chain, :child_filter
+      assert_equal 2, @child_filter_chain.size
+    end
+  end
+end

data/tests/models/accepts_nested_attributes_for_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'models/config'
+
+class AcceptsNestedAttributesForTest < Test::Unit::TestCase
+  include MammalSample
+
+  context "Assigning legs to the dog" do
+    setup do
+      initialize_db
+      create_mammals
+      create_legs
+
+      Mammal.class_eval do
+        has_many :legs
+        accepts_nested_attributes_for :legs, :reject_if => :all_blank
+      end
+    end
+
+    should "not fail if legs association added to re-opened Mammal class" do
+      assert_nothing_raised do
+        Dog.new :legs_attributes => [ { :length => :reach_ground } ]
+      end
+    end
+
+    should "support nested attributes on all descendent classes" do
+      assert_nothing_raised do
+        Beagle.new :legs_attributes => [ { :length => :awfully_short } ]
+      end
+    end
+
+  end
+
+end

data/tests/models/config.rb

@@ -0,0 +1,41 @@
+require 'sqlite3'
+
+module MammalSample
+
+  DATABASE_NAME = '.mammal.db'
+
+  class Leg < ActiveRecord::Base
+  end
+
+  class Mammal < ActiveRecord::Base
+  end
+
+  class Dog < Mammal
+  end
+
+  class Beagle < Dog
+  end
+
+  def initialize_db
+    SQLite3::Database.new(DATABASE_NAME)
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3',
+                                            :database => DATABASE_NAME)
+  end
+
+  def create_mammals
+    return if Mammal.table_exists?
+    ActiveRecord::Base.connection.create_table :mammals do |t|
+      t.string :type
+      t.timestamps
+    end
+  end
+
+  def create_legs
+    return if Leg.table_exists?
+    ActiveRecord::Base.connection.create_table :legs do |t|
+      t.string :length
+      t.timestamps
+    end
+  end
+
+end

data/tests/test_helper.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'test/unit'
+
+# tests are now awesome
+gem 'shoulda'
+require 'shoulda'
+
+# pretty colors
+gem 'redgreen'
+require 'redgreen'
+
+# need some rails bits
+gem 'actionpack'
+require 'action_controller'
+
+gem 'activerecord'
+require 'active_record'
+
+#my bits
+require 'rails_inheritable_attributes_manager'
+
+# some useful assertions
+
+def assert_contains_filter(collection, filter_name)
+  if collection.any? {|filter| filter.method == filter_name}
+    assert_block { true }
+  else
+    failure_msg = "#{filter_name.inspect} could not be found in #{collection.inspect}"
+    assert_block(failure_msg) { false }
+  end
+end
+
+def assert_filter_absent(collection, filter_name)
+  if collection.any? {|filter| filter.method == filter_name}
+    failure_msg = "#{filter_name.inspect} was unexpectedly found in #{collection.inspect}"
+    assert_block(failure_msg) { false }
+  else
+    assert_block { true }
+  end
+end
+
+def assert_chain_order(expected, chain)
+  chain_symbols = chain.map(&:method).map{ |f| f.is_a?(Proc) ? :a_proc : f.to_sym }
+  assert_equal expected, chain_symbols
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification 
+name: rails_inheritable_attributes_manager
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Ryan L. Bell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-07 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 10
+        - 2
+        version: 2.10.2
+  requirement: *id001
+  name: shoulda
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 2
+        - 2
+        version: 1.2.2
+  requirement: *id002
+  name: redgreen
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  requirement: *id003
+  name: actionpack
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  requirement: *id004
+  name: activerecord
+  prerelease: false
+  type: :development
+description: Enhances Rails inheritable attributes to ensure that changes to super classes are passed on to the subclasses
+email: ryan.l.bell@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- RELEASE_NOTES
+- Gemfile
+- init.rb
+- lib/models/nested_attributes.rb
+- lib/controllers/controller_filters.rb
+- lib/rails_inheritable_attributes_manager.rb
+- tests/models/accepts_nested_attributes_for_test.rb
+- tests/models/config.rb
+- tests/test_helper.rb
+- tests/controllers/normal_filter_chain_test.rb
+- tests/controllers/append_before_test.rb
+- tests/controllers/append_after_test.rb
+- tests/controllers/skip_after_test.rb
+- tests/controllers/prepend_after_test.rb
+- tests/controllers/deep_class_hierarchy_test.rb
+- tests/controllers/append_around_test.rb
+- tests/controllers/prepend_before_test.rb
+- tests/controllers/skip_test.rb
+- tests/controllers/prepend_around_test.rb
+- tests/controllers/skip_before_test.rb
+has_rdoc: true
+homepage: http://github.com/kofno/rails_inheritable_attributes_manager
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Manages inheritable attributes when super classes are re-opened
+test_files: []
+