object_id_gem 1.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 934ad550ee4c80cdbcd2328e27d88b80d9586f7faf3e780c7fe27ace3e0cb90c
+  data.tar.gz: 90254785189ba6af205e0712397047bb19817ee5d8f5cdb42eb59c8967e1e612
+SHA512:
+  metadata.gz: 4492abbc45cf0ec58722c0cdb261dd48ba60c7481f9e61e0a3ff06d263b275201c8386f7a4af5a19f576e9e661f23e6536eae1eac696a426cdb09126d033c0a2
+  data.tar.gz: a3f4425ec8ca9eb2bdab29eed7284cfbef46fac0c8274466a0dedc9f124e7ae69c212f875a8ab697ffedbd44a4c7e1e393db115d6454ecf6d2f0bb24787a3d21

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/spec_database_config.rb*

data/.travis.yml

@@ -0,0 +1,44 @@
+rvm:
+    - "1.8.7"
+    - "1.9.3"
+    - "2.0.0"
+    - "2.1.3"
+    - "jruby-1.7.16"
+env:
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.0.20 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=mysql
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.0.20 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=postgres
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.0.20 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.1.12 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=mysql
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.1.12 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=postgres
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.1.12 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.2.19 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=mysql
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.2.19 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=postgres
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=3.2.19 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=4.0.10 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=mysql
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=4.0.10 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=postgres
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=4.0.10 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=4.1.6 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=mysql
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=4.1.6 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=postgres
+    - OBJECTID_COLUMNS_AR_TEST_VERSION=4.1.6 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite
+before_script:
+    - mysql -e 'create database myapp_test;'
+    - psql -c 'create database myapp_test;' -U postgres
+matrix:
+    exclude:
+        # ActiveRecord 4.x doesn't support Ruby 1.8.7
+        -   rvm: 1.8.7
+            env: OBJECTID_COLUMNS_AR_TEST_VERSION=4.0.10 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=mysql
+        -   rvm: 1.8.7
+            env: OBJECTID_COLUMNS_AR_TEST_VERSION=4.0.10 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: 1.8.7
+            env: OBJECTID_COLUMNS_AR_TEST_VERSION=4.0.10 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite
+        -   rvm: 1.8.7
+            env: OBJECTID_COLUMNS_AR_TEST_VERSION=4.1.6 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=mysql
+        -   rvm: 1.8.7
+            env: OBJECTID_COLUMNS_AR_TEST_VERSION=4.1.6 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: 1.8.7
+            env: OBJECTID_COLUMNS_AR_TEST_VERSION=4.1.6 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite
+    allow_failures:
+        -   env: OBJECTID_COLUMNS_AR_TEST_VERSION=3.1.12 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite
+        -   rvm: 1.8.7
+            env: OBJECTID_COLUMNS_AR_TEST_VERSION=3.2.19 OBJECTID_COLUMNS_TRAVIS_CI_DATABASE_TYPE=sqlite

data/CHANGES.md

@@ -0,0 +1,23 @@
+# Change History for ObjectidColumns
+
+### Version 1.0.5: October 10, 2014
+
+* Fixed an issue where using `objectid_columns` on a parent model class that was then inherited from (via STI) could cause an internal exception.
+* Updated Travis testing specifications to the latest versions of Ruby/JRuby and ActiveRecord.
+
+### Version 1.0.3: June 11, 2014
+
+* Fixed an issue where, if you tried to declare `has_objectid_primary_key` on a table that didn't exist (usually meaning it just hadn't been migrated into existence yet), you'd get an error. Now, we ignore this declaration.
+
+### Version 1.0.2: April 14, 2014
+
+* Fixed an issue where, if you tried to pass an ObjectID instance in a `where` clause for a column that didn't exist or wasn't on a table that declared any ObjectID columns, you could get an error from deep down in `ObjectidColumns`. (Now, you'll still get an error, but it will be the ActiveRecord error you expect, instead.)
+* Rails 4.1 support.
+* Bumped Travis version matrix to the latest point-releases of Rails 3.2 and 4.0.
+
+### Version 1.0.1: March 7, 2014
+
+* Compatibility with the [`composite_primary_keys`](https://github.com/composite-primary-keys/composite_primary_keys)
+  gem, so that you can use object-ID columns as part of a composite primary key.
+* Fixed an issue where you could not save an ActiveRecord model that had an ObjectId column as its primary key.
+  Implemented this by teaching Arel how to deal with BSON ObjectIds, which should have broader benefits, too.

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Swiftype, Inc.
+
+MIT License
+
+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.md

@@ -0,0 +1,225 @@
+# ObjectidColumns
+
+Transparely store MongoDB [ObjectId](http://docs.mongodb.org/manual/reference/object-id/) values (the primary key of
+all MongoDB tables) in ActiveRecord objects in a relational database. You can store values as:
+
+* A binary column (`BINARY`, `VARBINARY`, `BLOB`, _etc._) of length at least 12; the ObjectId value will be stored as
+  pure binary data — the most efficient format. (Most databases, including MySQL and PostgreSQL, can index this
+  column and work with it just like a String; it just takes half as much space (!).)
+* A String column (`CHAR`, `VARCHAR`, _etc._) of length at least 24; the ObjectId value will be stored as a hexadecimal
+  string.
+
+(Note that it is not possible to store binary data transparently in a String column, because not all byte sequences
+are valid binary data in all possible character sets.)
+
+Once declared, an ObjectId column will return instances of either `BSON::ObjectId` or `Moped::BSON::ObjectId`
+(depending on which one you have loaded) when you access an attribute of a model that you've declared as an ObjectId
+column. It will accept a String (in either hex or binary formats) or an instance of either of those classes when
+assigning to the column.
+
+`ObjectidColumns` also allows you to use ObjectId values as primary keys; it will assign them to new records by
+default, and make sure `find(id)` accepts them.
+
+This gem requires either the `moped` gem (which defines `Moped::BSON::ObjectId`) or the `bson` gem (which defines
+`BSON::ObjectId`) for the actual ObjectId classes it uses. It declares an official dependency on neither, because we
+want to allow you to use either one. It will accept either one when assigning ObjectIds; it will return ObjectIds as
+whichever one you have loaded, (currently) preferring `BSON::ObjectId` if you have both.
+
+ObjectidColumns supports Ruby 1.8.7, 1.9.3, 2.0.0, and 2.1.0, plus JRuby 1.7.9; it supports ActiveRecord 3.0.20,
+3.1.12, 3.2.17, 4.0.4, and 4.1.0. It supports SQLite 3.x, MySQL 5.x, and PostgreSQL 8.x. (These are just the
+versions it's tested against; while it will not work with ActiveRecord 2.x, it is otherwise highly unlikely to
+be sensitive to exact ActiveRecord or Ruby versions, or type of RDBMS, and generally should work with most
+combinations.)
+
+*Note*: If you use SQLite3 with ActiveRecord 3.1.x on MRI (_i.e._, not JRuby), or SQLite3 with ActiveRecord 3.2.x on
+MRI 1.8.7, there is a bug in the SQLite3-ActiveRecord integration that causes ObjectId primary keys to not work. (They
+are inserted properly, but searching by primary key fails.) Needless to say, these are very rare combinations of
+software to be running in production, but it's worth noting. (ActiveRecord 3.0.x or 3.2.x work fine with SQLite3 on
+MRI; SQLite3 with ActiveRecord 3.2.x works fine on MRI >= 1.9.3; and MySQL and PostgreSQL work perfectly everywhere.)
+
+Current build status: ![Current Build Status](https://api.travis-ci.org/swiftype/objectid_columns.png?branch=master)
+
+Brought to you by the folks at [Swiftype](https://www.swiftype.com). First version written by [Andrew Geweke](https://www.github.com/ageweke).
+
+## Installation
+
+First, make sure you have either `BSON::ObjectId` or `Moped::BSON::ObjectId` defined in your Rails environment;
+these are the two ObjectId classes that `ObjectidColumns` can work with. If you don't have either defined, add one
+of these lines to your `Gemfile` (loading both is fine, but unnecessary):
+
+       gem 'bson'
+    OR gem 'moped'
+
+Now, add this line to your application's Gemfile:
+
+    gem 'objectid_columns'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install objectid_columns
+
+## Usage
+
+If you name your object-ID columns with `_oid` at the end, simply do this:
+
+    class MyModel < ActiveRecord::Base
+      has_objectid_columns
+    end
+
+This will automatically find any columns that end in `_oid` and make them ObjectId columns. When reading them, you will
+get back an instance of an ObjectId class (from `moped` or `bson`, depending on which one you have loaded; see the
+introduction for more). When writing them, you can assign a String in hex or binary formats, or an instance of either
+of the supported ObjectId classes.
+
+If you didn't name your columns this way, or _don't_ want to pick up columns ending in `_oid`, just name them
+explicitly:
+
+    class MyModel < ActiveRecord::Base
+      has_objectid_columns :some_oid, :foo
+    end
+
+This will not only define `some_oid` and `foo` as being ObjectId columns, but it will also skip the automatic detection
+of columns ending in `_oid`.
+
+ObjectidColumns will never automatically make a primary-key column an ObjectId, even if it ends with `_oid`; if you
+want a primary key to be an ObjectId, you must do that explicitly, using `has_objectid_primary_key`, below.
+
+Note that trying to declare a column as an ObjectId column if it isn't of a supported type (a type that ActiveRecord
+considers to be `:string` or `:binary`), or if it isn't long enough to support an ObjectId (twelve characters for
+binary columns, 24 for string columns); this will happen from the `has_objectid_columns` call (so at load time for the
+model class).
+
+Once you have declared such a column:
+
+    my_model = MyModel.find(...)
+
+    my_model.my_oid                    # => BSON::ObjectId('52eab2cf78161f1314000001')
+    my_model.my_oid.to_s               # => "52eab2cf78161f1314000001" (built-in behavior from BSON::ObjectId)
+    my_model.my_oid.to_binary          # => "R\xEA\xB2\xCFx\x16\x1F\x13\x14\x00\x00\x01"
+    my_model.my_oid.to_binary.encoding # => #<Encoding:ASCII-8BIT>
+
+    my_model.my_oid = BSON::ObjectId.new         # OK
+    my_model.my_oid = "52eab32878161f1314000002" # OK
+    my_model.my_oid = "R\xEA\xB2\xCFx\x16\x1F\x13\x14\x00\x00\x01" # OK
+
+    MyModel.where(:my_oid => some_oid).first # => my_model -- i.e., where(...) works with a hash.
+
+Note that to assign a binary-format string, it must have an encoding of `Encoding::BINARY` (which is an alias for
+`Encoding::ASCII-8BIT`). (If your string has a different encoding, it may be coming from a source that does not
+actually support full binary data transparently, which _will_ cause big problems.)
+
+### Gotchas
+
+If you query on an ObjectId column and use the hash syntax &mdash; _i.e._, `MyModel.where(:some_oid => ...)` &mdash;
+then everything will work perfectly; `ObjectidColumns` looks for this syntax and properly translates the value from
+an ObjectId object, binary String, or hex String to the proper database value. On the other hand, if you specify a
+SQL statement or fragment of SQL yourself, you must do the translation, or you'll either get a database error or just
+no rows found:
+
+    MyModel.where("some_oid = ?", my_oid.to_bson_id.to_binary) # if some_oid is binary
+    MyModel.where("some_oid = ?", my_oid.to_bson_id.to_s)      # if some_oid is a String
+
+(Without actively parsing SQL, which is kind of an insane thing to do, there is no easy way around this. Even if we
+detected ObjectId objects in the set of values passed in, we'd have no way of figuring out which ObjectId column they
+were constraining on, and thus whether to turn them into binary or hexadecimal ObjectId values.)
+
+### Using an ObjectId for a Primary Key
+
+You can use ObjectId values as primary keys:
+
+    class MyModel < ActiveRecord::Base
+      has_objectid_primary_key
+    end
+
+Perhaps obviously, your primary-key column must either be `:binary` of length >= 12 or `:string` of length >= 24.
+
+If your primary-key column is not called `:id`, you must do one of two things:
+
+* Set the primary key on the class _before_ you call `has_objectid_primary_key`, by just using the normal ActiveRecord
+  `self.primary_key = :foo` syntax.
+* Pass the primary key as an argument to `has_objectid_primary_key`: `has_objectid_primary_key :foo`.
+
+(The two are exactly equivalent.)
+
+When you do this, `ObjectidColumns` adds a `before_create` hook to your model, assigning a new ObjectId immediately
+before the first time a row is saved in the database. This will not replace an existing ID, so, if you always (or
+sometimes) assign a new ID yourself, `ObjectidColumns` will not overwrite your ID.
+
+Perhaps obviously, this means that new IDs are generated and stored client-side; you almost certainly should declare
+your primary-key column as `NOT NULL`, but you don't need to give it a default (and probably shouldn't, unless you're
+using a database function that is capable of generating correctly-formatted ObjectId values using the correct
+algorithm).
+
+
+### Setting the Preferred Class
+
+If you have both the `bson` and `moped` gems defined, then, by default, ObjectId columns will be returned as instances
+of `bson`'s `BSON::ObjectId` class. If you want to use `moped`'s instead, do this:
+
+    ObjectidColumns.preferred_bson_class = Moped::BSON::ObjectId
+
+### Extensions
+
+This gem extends String with a single method, `#to_bson_id`; it simply returns an instance of the preferred BSON class
+from that String if it's in either the valid hex or the valid binary format, or raises `ArgumentError` otherwise.
+
+This gem also extends whatever BSON ObjectId classes are loaded with methods `to_bson_id` (which just returns `self`),
+and the method `to_binary`, which returns a binary String of length 12 for that object ID.
+
+### Running Specs
+
+`objectid_columns` has thorough system-level (_i.e._, integration) tests, written in RSpec. Because nearly all of its
+functionality is centered around interfacing with ActiveRecord (as opposed to having significant, complex code within
+its codebase directly), there are no unit tests &mdash; they would simply be setting complex expectations around calls
+to ActiveRecord, making the tests fragile and not particularly useful.
+
+In order to run these specs, you must have access to a database you can use. It's best if the database is dedicated
+to running these specs. The tests create and destroy their own tables, and make every effort to clean up anything they
+created at the end &mdash; so it should be possible to piggyback on top of an existing database you also use for other
+things. However, it's _always_ much safer to use a dedicated database. (Note that this is intentional use of the word
+"database", as opposed to "database server"; you don't need, for example, an entirely separate instance of `mysqld`
+&mdash; just a separate database that you can switch to using `USE ....`.)
+
+Once you have this set up, simply create a file at the root level of the Gem (_i.e._, inside the root
+`objectid_columns` directory) called `spec_database_config.rb`, and define a constant
+`OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG` as so:
+
+    OBJECTID_COLUMNS_SPEC_DATABASE_CONFIG = {
+      :database_gem_name => 'mysql2',
+      :require => 'mysql2',
+      :config => {
+        :adapter => 'mysql2',
+        :database => 'objectid_columns_specs_db',
+        :username => 'root'
+      }
+    }
+
+The keys are as follows:
+
+* `:database_gem_name` is the name of the RubyGem that provides access to the database &mdash; exactly as you'd put
+  it in a `Gemfile`;
+* `:require` is whatever should be passed to Ruby's built-in `require` statement to require the Gem &mdash;
+   typically this is the same as `:database_gem_name`, but not always (this is the same as a Gemfile's `:require => ..
+   ` syntax);
+* `:config` is exactly what gets passed to `ActiveRecord::Base.establish_connection`, and so you can pass any
+  options that it accepts (which are the same as what goes in Rails' `database.yml`).
+
+Once you've done this, you can run the system specs using `bundle exec rspec spec/objectid_columns/system`. (Or run
+them along with the unit specs with a simple `bundle exec rspec spec`.)
+
+Note that there's also support deep in the code (in
+`objectid_columns/spec/objectid_columns/helpers/database_helper.rb`)
+for defining connections to [Travis CI](https://travis-ci.org/)'s database options, so that Travis can run the tests
+automatically. Generally, you don't need to worry about this, but it's worth noting.
+
+## Contributing
+
+1. Fork it ( http://github.com/swiftype/objectid_columns/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/objectid_columns.rb

@@ -0,0 +1,127 @@
+require "objectid_columns/version"
+require "objectid_columns/active_record/base"
+require "objectid_columns/active_record/relation"
+require "objectid_columns/arel/visitors/to_sql"
+require "active_record"
+
+# This is the root module for ObjectidColumns. It contains largely just configuration and integration information;
+# all the real work is done in ObjectidColumns::ObjectidColumnsManager. ObjectidColumns gets its start through the
+# module ObjectidColumns::ActiveRecord::Base, which gets mixed into ::ActiveRecord::Base (below) and is where methods
+# like +has_objectid_columns+ are declared.
+module ObjectidColumns
+  class << self
+    # This is the set of classes we support for representing ObjectIds, as objects, themselves. BSON::ObjectId comes
+    # from the +bson+ gem, and Moped::BSON::ObjectId comes from the +moped+ gem.
+    #
+    # Note that this gem does not declare a dependency on either one of these gems, because we want you to be able to
+    # use either, and there's currently no way of expressing that explicitly. Instead,
+    # .available_objectid_columns_bson_classes, below, takes care of figuring out which ones are availble and loading
+    # them.
+    #
+    # Order is important here: when creating new ObjectId objects (such as when reading from an ObjectId column), we
+    # will prefer the earliest one of these classes that is actually defined. You can change this using
+    # .preferred_bson_class=, below.
+    #
+    #
+    # Any class added here has to obey the following constraints:
+    #
+    # * You can create a new instance from a hex string using .from_string(hex_string)
+    # * Calling #to_s on it returns a hexadecimal String of exactly 24 characters
+    #
+    # Both these objects currently do. If they change, or you want to introduce a new ObjectId representation class,
+    # a small amount of refactoring will be necessary.
+    SUPPORTED_OBJECTID_BSON_CLASS_NAMES = %w{BSON::ObjectId Moped::BSON::ObjectId}
+
+    # When we create a new ObjectId object (such as when reading from a column), what class should it be? If you have
+    # multiple classes loaded and you don't like this one, you can call .preferred_bson_class=, below.
+    def preferred_bson_class
+      @preferred_bson_class ||= available_objectid_columns_bson_classes.first
+    end
+
+    # Sets the preferred BSON class to the given class.
+    def preferred_bson_class=(bson_class)
+      unless SUPPORTED_OBJECTID_BSON_CLASS_NAMES.include?(bson_class.name)
+        raise ArgumentError, "ObjectidColumns does not support BSON class #{bson_class.name}; it supports: #{SUPPORTED_OBJECTID_BSON_CLASS_NAMES.inspect}"
+      end
+
+      @preferred_bson_class = bson_class
+    end
+
+    # Returns an array of Class objects -- of length at least 1, but potentially more than 1 -- of the various
+    # ObjectId classes we have available to use. Again, because we don't explicitly depend on the BSON gems
+    # (see above), this needs to take care of trying to load and require the gems in question, and fail gracefully
+    # if they're not present.
+    def available_objectid_columns_bson_classes
+      @available_objectid_columns_bson_classes ||= begin
+        # Try to load both gems, but don't fail if there are errors
+        %w{moped bson}.each do |require_name|
+          begin
+            gem require_name
+          rescue Gem::LoadError => le
+          end
+
+          begin
+            require require_name
+          rescue LoadError => le
+          end
+        end
+
+        # See which classes we have managed to load
+        defined_classes = SUPPORTED_OBJECTID_BSON_CLASS_NAMES.map do |name|
+          eval("if defined?(#{name}) then #{name} end")
+        end.compact
+
+        # Raise an error if we haven't loaded either
+        if defined_classes.length == 0
+          raise %{ObjectidColumns requires a library that implements an ObjectId class to be loaded; we support
+the following ObjectId classes: #{SUPPORTED_OBJECTID_BSON_CLASS_NAMES.join(", ")}.
+(These are from the 'bson' or 'moped' gems.) You seem to have neither one installed.
+
+Please add one of these gems to your project and try again. Usually, this just means
+adding this to your Gemfile:
+
+gem 'bson'
+
+(ObjectidColumns does not explicitly depend on either of these, because we want you
+to be able to choose whichever one you prefer.)}
+        end
+
+        defined_classes
+      end
+    end
+
+    # Is the given object a valid BSON ObjectId? This doesn't count Strings in any format -- only objects.
+    def is_valid_bson_object?(x)
+      available_objectid_columns_bson_classes.detect { |k| x.kind_of?(k) }
+    end
+
+    # Creates a new BSON ObjectId from the given String, which must be in the hexadecimal format.
+    def construct_objectid(hex_string)
+      preferred_bson_class.send(:from_string, hex_string)
+    end
+
+    # Creates a new BSON ObjectId, from scratch; this must return an ObjectId with a value, suitable for assigning
+    # to a newly-created row. We use this only if you've declared that your primary key column is an ObjectId, and
+    # then only if you're about to save a new row and it has no ID yet.
+    def new_objectid
+      preferred_bson_class.new
+    end
+  end
+end
+
+# Include the modules that add the initial methods to ActiveRecord::Base, like +has_objectid_columns+.
+::ActiveRecord::Base.class_eval do
+  include ::ObjectidColumns::ActiveRecord::Base
+end
+
+# This adds our patch to +#where+, so that queries will work properly (assuming you use Hash-style syntax).
+::ActiveRecord::Relation.class_eval do
+  include ::ObjectidColumns::ActiveRecord::Relation
+end
+
+# require 'arel/visitors/to_sql'
+::Arel::Visitors::ToSql.class_eval do
+  include ::ObjectidColumns::Arel::Visitors::ToSql
+end
+
+require "objectid_columns/extensions"