active_record_ignored_attributes 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in active_record_ignored_attributes.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler/gem_tasks'
+
+#require 'bundler'
+#begin
+#  Bundler.setup(:default, :development)
+#rescue Bundler::BundlerError => e
+#  $stderr.puts e.message
+#  $stderr.puts "Run `bundle install` to install missing gems"
+#  exit e.status_code
+#end
+
+#---------------------------------------------------------------------------------------------------
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec

data/Readme.md

@@ -0,0 +1,220 @@
+ActiveRecord Ignored Attributes
+===============================
+
+Adds various behavior to Active Record models relating to the model's attributes: 
+
+* Allows you to compare Active Record objects based on their *attributes*, which often makes more sense than the built-in `==` operator (which does its comparisons based on the `id` attribute alone! — not always what you want!)
+* You can configure which attributes, if any, should be excluded from the comparison
+* Provides a customizable inspect method, which by default excludes the same attributes that are excluded when doing a `same_attributes_as?` comparison
+
+Example
+=======
+
+Consider a User model that holds the notion of users that have a name.
+
+    ActiveRecord::Schema.define do
+      create_table :addresses, :force => true do |t|
+        t.string   :name
+        t.text     :address
+        t.string   :city
+        t.string   :state
+        t.string   :postal_code
+        t.string   :country
+        t.timestamps
+      end
+    end
+
+    class Address < ActiveRecord::Base
+    end
+
+
+Default ActiveRecord `==` behavior:
+
+    a = Address.new(address: 'B St.')
+    b = Address.new(address: 'B St.')
+    a == b # => false
+
+Using `same_as?`:
+
+    a = Address.new(address: 'B St.')
+    b = Address.new(address: 'B St.')
+    a.same_as?(b) # => true
+
+    a = Address.new(address: 'B St.')
+    b = Address.new(address: 'Nowhere Road')
+    a.same_as?(b) # => false
+
+
+Installing
+==========
+
+Add to your `Gemfile`:
+
+<pre>
+gem "active_record_attributes_equality"
+</pre>
+
+If you want to *replace* the default ActiveRecord `==` operator with the `same_as?` behavior, you should be able to just override it, like this:
+
+    class ActiveRecord::Base
+      alias_method :==, :same_as?
+    end
+
+Configuring which attributes are ignored
+========================================
+
+By default, `id`, `created_at`, and `updated_at` will be ignored.
+
+If you want to *add* some ignored attributes to the default array (`[:id, :created_at, :updated_at]`), you can override `self.ignored_attributes` like so, referencing `super`:
+
+    class Address < ActiveRecord::Base
+      def self.ignored_attributes
+        super + [:name]
+      end
+    end
+
+If you want to override the defaults instead of appending to them, just don't reference `super`:
+
+    class Address < ActiveRecord::Base
+      def self.ignored_attributes
+        [:id, :name]
+      end
+    end
+
+`inspect_without_ignored_attributes`
+------------------------------------
+
+Now that you've declared which attributes you don't really care about, how about making it so you don't have to see them in your `inspect` output too? (The output from `inspect` is verbose enough as it is!!)
+
+If you want to occasionally see the same output as the default `inspect` but without all those ignored attributes showing up, you can just call `object.inspect_without_ignored_attributes`:
+
+    address.inspect_without_ignored_attributes # => "#<Address address: nil, city: nil, country: nil, postal_code: nil, state: nil>"
+
+    # Compared to:
+    address.inspect                            # => "#<Address id: 1, name: nil, address: nil, city: nil, state: nil, postal_code: nil, country: nil, created_at: \"2011-08-19 18:07:39\", updated_at: \"2011-08-19 18:07:39\">"
+  
+But that is a lot to type every time. If you want inspect to *always* be more readable, you can override the ActiveRecord default like this:
+
+    class Address < ActiveRecord::Base
+      alias_method :inspect, :inspect_without_ignored_attributes
+    end
+
+or even:
+
+    class ActiveRecord::Base
+      alias_method :inspect, :inspect_without_ignored_attributes
+    end
+
+Customizable inspect method
+---------------------------
+
+If you want to customize inspect further and specify exactly which attributes to show (and, optionally which delimiters to bracket the string with), you can use `inspect_with`:
+
+    class Address < ActiveRecord::Base
+      def inspect
+        inspect_with([:city, :state, :country])
+      end
+    end
+
+or:
+
+    class Address < ActiveRecord::Base
+      def inspect
+        inspect_with([:id, :name, :address, :city, :state, :postal_code, :country], ['{', '}'])
+      end
+    end
+
+
+RSpec
+=======
+
+This gem comes with a `be_same_as` matcher for RSpec.
+
+Add this to your spec_helper.rb:
+
+    require 'active_record_ignored_attributes/matchers'
+
+Then in your specs you can write such nicely readable expectations as:
+
+    expected = Address.new({city: 'City', country: 'USA'})
+    Address.last.should be_same_as(expected)
+
+    a = Address.new(address: 'B St.')
+    b = Address.new(address: 'B St.')
+    a.should be_same_as?(b) # passes
+
+    a = Address.new(address: 'B St.')
+    b = Address.new(address: 'Nowhere Road')
+    a.should be_same_as?(b) # fails
+
+and it will lovingly do a diff for you and only show you the attributes in each object that actually differed:
+
+    expected: #<Address address: "Nowhere Road">
+         got: #<Address address: "B St.">
+
+
+
+Motivation
+==========
+
+The default ActiveRecord `==` behavior isn't always adequate, as you can probably tell from the example at the top, or by the fact that you are looking at this gem right now.
+
+This is the implementation of `==` in [ActiveRecord](https://github.com/rails/rails/blob/3-0-10/activerecord/lib/active_record/base.rb):
+
+    # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
+    # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
+    #
+    # Note that new records are different from any other record by definition, unless the
+    # other record is the receiver itself. Besides, if you fetch existing records with
+    # +select+ and leave the ID out, you're on your own, this predicate will return false.
+    #
+    # Note also that destroying a record preserves its ID in the model instance, so deleted
+    # models are still comparable.
+    def ==(comparison_object)
+      comparison_object.equal?(self) ||
+        (comparison_object.instance_of?(self.class) &&
+          comparison_object.id == id && !comparison_object.new_record?)
+    end
+
+That implementation is often fine when you are dealing with saved records, but isn't helpful *at all* when one or both of the objects being compared is not-yet-saved.
+
+If you want to compare two model instances based on their attributes, you will probably want to *exclude* certain irrelevant attributes from your comparison, such as: `id`, `created_at`, and `updated_at`. (I would consider those to be more *metadata* about the record than part of the record's data itself.)
+
+This might not matter when you are comparing two new (unsaved) records (since `id`, `created_at`, and `updated_at` will all be `nil` until saved), but I sometimes find it necessary to compare a *saved* object with an *unsaved* one (in which case == would give you false since nil != 5). Or I want to compare two *saved* objects to find out if they contain the same *data* (so the ActiveRecord `==` operator doesn't work, because it returns false if they have different `id`'s, even if they are otherwise identical).
+
+See also: http://stackoverflow.com/questions/4738439/how-to-test-for-activerecord-object-equality
+
+
+Questions and Ideas
+===================
+
+* Does such a gem already exist?
+  * All I've found so far is https://github.com/GnomesLab/active_record_attributes_equality
+* What should the method be called? I don't think overriding the existing `==` operator is a good idea (as done in [active_record_attributes_equality](https://github.com/GnomesLab/active_record_attributes_equality)), so for now I'm calling it `same_attributes_as?` (aliased as `same_as?` since that's easier to type). Other runners up were `practically_same_as?` and `attributes_eql?`.
+
+
+Possible improvements:
+
+* Allow the default to be overridden with a class macro like `ignore_for_attributes_eql :last_signed_in_at, :updated_at` 
+
+Also, perhaps you want to set the default ignored attributes for a model but still wish to be able to override these defaults as needed...
+
+    address.same_as?(other_address, :ignore => [:addressable_type, :addressable_id])
+    address.same_as?(other_address, :only => [:city, :state, :country])
+
+
+Contributing
+============
+
+Comments and contributions are welcome.
+
+Please feel free to fork the project at http://github.com/TylerRick/active_record_ignored_attributes and to send pull requests.
+
+Bugs can be reported at https://github.com/TylerRick/active_record_ignored_attributes/issues
+
+License
+=======
+
+Copyright 2011, Tyler Rick
+
+This is free software, distributed under the terms of the MIT License.

data/active_record_ignored_attributes.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_record_ignored_attributes/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_record_ignored_attributes"
+  s.version     = ActiveRecordIgnoredAttributes::Version
+  s.authors     = ["Tyler Rick"]
+  s.email       = ["tyler@tylerrick.com"]
+  s.homepage    = ""
+  s.summary     = %q{Allows you to compare Active Record objects based on their *attributes* (with same_as?), to exclude some attributes from being used in comparison, and adds improved inspect method}
+  s.description = s.summary
+
+  s.add_dependency             'activerecord'
+  s.add_dependency             'facets'
+
+  s.add_development_dependency 'rspec'
+ #s.add_development_dependency 'rcov'
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'mysql2', '~>0.2.11'
+  s.add_development_dependency 'rr'
+  s.add_development_dependency 'activesupport'
+  s.add_development_dependency 'ruby-debug19'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/active_record_ignored_attributes/inspect.rb

@@ -0,0 +1,20 @@
+require 'facets/string/bracket'
+
+module ActiveRecordIgnoredAttributes::Inspect
+
+  # TODO: brackets = self.class.default_brackets_for_inspect (configurable via class_inheritable_accessor)
+
+  def inspect_with(attr_names, brackets = ['#<', '>'])
+    attr_names ||= id
+    body = attr_names.map {|name|
+      "#{name}: #{send(name).inspect}"
+    }.join(', ')
+
+    "#{self.class} #{body}".
+      bracket(*brackets)
+  end
+
+  def inspect_without_ignored_attributes
+    inspect_with(attributes.keys - self.class.ignored_attributes.map(&:to_s))
+  end
+end

data/lib/active_record_ignored_attributes/matchers/be_same_as.rb

@@ -0,0 +1,22 @@
+RSpec::Matchers.define :be_same_as do |expected|
+  match do |actual|
+    actual.same_as?(expected)
+  end
+
+  failure_message_for_should do |actual|
+   #%(#{actual.inspect_without_ignored_attributes} was expected to have the same attributes as\n) +
+   #%(#{expected.inspect_without_ignored_attributes})
+
+    attr_names_that_differed = actual.attributes_without_ignored_attributes.select do |k,v|
+      expected[k] != v
+    end.map(&:first)
+    # TODO: pass extra option to inspect_with (such as the other object) so that it can use the same width for each attribute so that they line up nicely and are easy to visually compare
+    %(expected: #{expected.inspect_with(attr_names_that_differed)}\n) +
+    %(     got: #{actual.inspect_with(attr_names_that_differed)})
+  end
+
+  failure_message_for_should_not do |actual|
+    %(         expected: #{expected.inspect}\n) +
+    %(to not be same_as: #{actual.inspect})
+  end
+end

data/lib/active_record_ignored_attributes/matchers.rb

@@ -0,0 +1 @@
+require 'active_record_ignored_attributes/matchers/be_same_as'

data/lib/active_record_ignored_attributes/same_attributes_as.rb

@@ -0,0 +1,7 @@
+module ActiveRecordIgnoredAttributes::SameAttributesAs
+  def same_attributes_as?(other)
+    self. attributes_without_ignored_attributes ==
+    other.attributes_without_ignored_attributes
+  end
+  alias_method :same_as?, :same_attributes_as?
+end

data/lib/active_record_ignored_attributes/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordIgnoredAttributes
+  Version = "0.0.1"
+end

data/lib/active_record_ignored_attributes.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+require "active_record_ignored_attributes/version"
+require "active_record_ignored_attributes/inspect"
+require "active_record_ignored_attributes/same_attributes_as"
+
+module ActiveRecordIgnoredAttributes
+  extend ActiveSupport::Concern
+
+  included do
+    # TODO: class_inheritable_accessor
+    def self.ignored_attributes
+      [:id, :created_at, :updated_at]
+    end
+  end
+
+  def attributes_without_ignored_attributes
+    attributes.except(*self.class.ignored_attributes.map(&:to_s))
+  end
+  
+end
+
+ActiveRecord::Base.class_eval do
+  include ActiveRecordIgnoredAttributes
+  include ActiveRecordIgnoredAttributes::SameAttributesAs
+  include ActiveRecordIgnoredAttributes::Inspect
+end

data/spec/attributes_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Address do
+  describe 'attributes_without_ignored_attributes' do
+    let(:address) { Address.create! }
+    it 'should not include any of the ignored attributes' do
+      address.attributes_without_ignored_attributes.tap do |attributes|
+        attributes.should be_a(Hash)
+        attributes.should_not have_key('id')
+        attributes.should_not have_key('created_at')
+        attributes.should_not have_key('updated_at')
+        attributes.should_not have_key('name')
+      end
+
+      # Plain old 'attributes', on the other hand, does include them
+      address.attributes.tap do |attributes|
+        attributes.should be_a(Hash)
+        attributes.should have_key('id')
+        attributes.should have_key('created_at')
+        attributes.should have_key('updated_at')
+      end
+    end
+
+    it 'should include all of the non-ignored attributes' do
+      address.attributes_without_ignored_attributes.tap do |attributes|
+        attributes.should be_a(Hash)
+        [:address, :city, :state, :postal_code, :country].each do |attr_name|
+          #puts "attributes.has_key?(#{attr_name})=#{attributes.has_key?(attr_name)}"
+          attributes.should have_key(attr_name.to_s)
+        end
+      end
+    end
+  end
+end

data/spec/inspect_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Address do
+  describe 'inspect_without_ignored_attributes' do
+    let(:address) { Address.create }
+    it do
+      address.inspect_without_ignored_attributes.should_not match(/id:/)
+      address.inspect_without_ignored_attributes.should_not match(/name:/)
+      address.inspect_without_ignored_attributes.should_not match(/created_at:/)
+      address.original_inspect.should                match(/#<Address id: \d+, .* created_at: ".*", updated_at: ".*">/)
+      address.inspect_without_ignored_attributes.should == "#<Address address: nil, city: nil, country: nil, postal_code: nil, state: nil>"
+    end
+  end
+
+  describe 'inspect' do
+    let(:address) { Address.create }
+    it do
+      address.inspect.should match(/{Address id: \d+, name: nil, address: nil, city: nil, state: nil, postal_code: nil, country: nil}/)
+    end
+  end
+end

data/spec/matchers_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+require 'active_support/core_ext/string/strip'
+
+describe "be_same_as" do
+  it "delegates to same_as?" do
+    object, other = Object.new, Object.new
+    mock(object).same_as?(other) { true }
+    object.should be_same_as(other)
+  end
+
+  it "reports a nice failure message for should" do
+    object, other = Address.new(address: 'A Street'), Address.new(address: 'B Street')
+    expect do
+      object.should be_same_as(other)
+    end.should raise_error(<<-End.strip_heredoc.chomp)
+    expected: #<Address address: "B Street">
+         got: #<Address address: "A Street">
+    End
+  end
+
+  it "reports a nice failure message for should_not" do
+    object, other = Address.new(address: 'A Street'), Address.new(address: 'A Street')
+    expect do
+      object.should_not be_same_as(other)
+    end.should raise_error(<<-End.strip_heredoc.chomp)
+         expected: {Address id: nil, name: nil, address: "A Street", city: nil, state: nil, postal_code: nil, country: nil}
+to not be same_as: {Address id: nil, name: nil, address: "A Street", city: nil, state: nil, postal_code: nil, country: nil}
+    End
+  end
+end

data/spec/same_as_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Address do
+  describe 'same_as?' do
+    let(:address) { Address.new }
+
+    it 'should return false even if any of the non-ignored attributes differ' do
+      a = Address.new(address: '123 A Street')
+      b = Address.new(address: '345 K Street')
+
+      a.should_not be_same_as(b)
+      a.attributes.should_not == b.attributes
+      a.attributes_without_ignored_attributes.should_not == b.attributes_without_ignored_attributes
+    end
+
+    it 'should still return true even if some of the ignored attributes differ' do
+      a = Address.new(name: 'A', address: 'The Same Address')
+      b = Address.new(name: 'B', address: 'The Same Address')
+
+      a.should be_same_as(b)
+      a.attributes.should_not == b.attributes
+      a.attributes_without_ignored_attributes.should == b.attributes_without_ignored_attributes
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+__DIR__ = Pathname.new(__FILE__).dirname
+$LOAD_PATH.unshift __DIR__
+$LOAD_PATH.unshift __DIR__ + '../lib'
+
+#---------------------------------------------------------------------------------------------------
+# ActiveRecord
+
+require 'active_record'
+driver = ENV["DB"] || 'sqlite3'
+#require driver
+database_config = YAML::load(File.open(__DIR__ + "support/database.#{driver}.yml"))
+ActiveRecord::Base.establish_connection(database_config)
+
+#---------------------------------------------------------------------------------------------------
+# RSpec
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end
+
+require 'active_record_ignored_attributes'
+require 'active_record_ignored_attributes/matchers'
+
+# Requires supporting ruby files in spec/support/
+Dir[__DIR__ + 'support/**/*.rb'].each do |f|
+  require f
+end

data/spec/support/database.mysql2.yml

@@ -0,0 +1,3 @@
+adapter: mysql2
+database: active_record_ignored_attributes_test
+username: root

data/spec/support/database.sqlite3.yml

@@ -0,0 +1,2 @@
+adapter: sqlite3
+database: ":memory:"

data/spec/support/models/address.rb

@@ -0,0 +1,11 @@
+class Address < ActiveRecord::Base
+  alias_method :original_inspect, :inspect
+
+  def inspect
+    inspect_with([:id, :name, :address, :city, :state, :postal_code, :country], ['{', '}'])
+  end
+
+  def self.ignored_attributes
+    super + [:name]
+  end
+end

data/spec/support/schema.rb

@@ -0,0 +1,12 @@
+ActiveRecord::Schema.define do
+  create_table :addresses, :force => true do |t|
+    t.string   :name
+    t.text     :address
+    t.string   :city
+    t.string   :state
+    t.string   :postal_code
+    t.string   :country
+    t.timestamps
+  end
+end
+

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification 
+name: active_record_ignored_attributes
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tyler Rick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-19 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: facets
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.2.11
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug19
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: Allows you to compare Active Record objects based on their *attributes* (with same_as?), to exclude some attributes from being used in comparison, and adds improved inspect method
+email: 
+- tyler@tylerrick.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- Readme.md
+- active_record_ignored_attributes.gemspec
+- lib/active_record_ignored_attributes.rb
+- lib/active_record_ignored_attributes/comparison.rb
+- lib/active_record_ignored_attributes/inspect.rb
+- lib/active_record_ignored_attributes/matchers.rb
+- lib/active_record_ignored_attributes/matchers/be_same_as.rb
+- lib/active_record_ignored_attributes/same_attributes_as.rb
+- lib/active_record_ignored_attributes/version.rb
+- spec/attributes_spec.rb
+- spec/inspect_spec.rb
+- spec/matchers_spec.rb
+- spec/same_as_spec.rb
+- spec/spec_helper.rb
+- spec/support/database.mysql2.yml
+- spec/support/database.sqlite3.yml
+- spec/support/models/address.rb
+- spec/support/schema.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Allows you to compare Active Record objects based on their *attributes* (with same_as?), to exclude some attributes from being used in comparison, and adds improved inspect method
+test_files: []
+