objectid_columns 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA512: 
-  metadata.gz: 8752dd26c637b7ba079438edd6abedce5c7df3fe44965c176f3aa3b3c137b1fbd504d5193e69e6d6ac200d445fe1e2808b04d494395c304b92c0b6878838f43e
-  data.tar.gz: aecea712ee39f11a59e245bce3d89136415b3429317500f4b8087c8e3b90b53ca6df937b904ca7f0abfc328f6961016105422ca94a6b4bfd99ad98644758e472
+  metadata.gz: 216e3a0b18aa9ff589f728a7ba6d95fa56ada067b51a99cff26dac0b19cb3f49cb4fa9deb2b2ae227498123bb5d8aa286aa76760eed1fbf96cfc6599dd7e423f
+  data.tar.gz: c9a48a9b4e065da3a3b45555cf7c2acd0c3a5687c6e5cf752318934553110fed9906d7d72b4e87cef431a4df7386e5fab1001c0ffbcf4cef655b8e59f8d1a169
 SHA1: 
-  metadata.gz: a55261b9a4c1cdf209e6b14c9d04a5a8aa0ff38d
-  data.tar.gz: fc27e32b0629998e0aa28180ba01cbb71ae1fc29
+  metadata.gz: 522783d13b6a7e03735ae0c8d793a545ef4926aa
+  data.tar.gz: c69aed130528349b56f2c60effed8ca0e73213eb

data/CHANGES.md

@@ -0,0 +1,8 @@
+# Change History for ObjectidColumns
+
+### 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/lib/objectid_columns.rb

@@ -1,6 +1,7 @@
 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;
@@ -118,4 +119,9 @@ end
   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"

data/lib/objectid_columns/arel/visitors/to_sql.rb

@@ -0,0 +1,89 @@
+require 'active_support'
+
+module ObjectidColumns
+  module Arel
+    module Visitors
+      # This module gets mixed into Arel::Visitors::ToSql, which is the class that the Arel gem (which is really the
+      # backbone of ActiveRecord's query language) uses to generate SQL. This teaches Arel what to do when it bumps
+      # into an object of a BSON ID class -- _i.e._, how to convert it to a SQL literal.
+      #
+      # How this works depends on which version of ActiveRecord -- and therefore AREL -- you're using:
+      #
+      # * In Arel 4.x, the #visit... methods get called with two arguments. The first is the actual BSON ID that needs
+      #   to be converted; the second provides context. From the second parameter, we can get the table name and
+      #   column name. We use this to get a hold of the ObjectidColumnsManager via its class method .for_table, and,
+      #   from there, a converted, valid value for the column in question (whether hex or binary).
+      # * In Arel 2.x (AR 3.0.x) and 3.x, we have to monkeypatch the #visit_Arel_Attributes_Attribute method -- it
+      #   already picks up and stashes away the .last_column, but we need to add the .last_relation, too.
+      #
+      module ToSql
+        extend ActiveSupport::Concern
+
+        require 'arel'
+        if ::Arel::VERSION =~ /^[23]\./
+          def visit_Arel_Attributes_Attribute_with_objectid_columns(o, *args)
+            out = visit_Arel_Attributes_Attribute_without_objectid_columns(o, *args)
+            self.last_relation = o.relation
+            out
+          end
+
+          included do
+            alias_method_chain :visit_Arel_Attributes_Attribute, :objectid_columns
+
+            alias :visit_Arel_Attributes_Integer :visit_Arel_Attributes_Attribute_with_objectid_columns
+            alias :visit_Arel_Attributes_Float :visit_Arel_Attributes_Attribute_with_objectid_columns
+            alias :visit_Arel_Attributes_Decimal :visit_Arel_Attributes_Attribute_with_objectid_columns
+            alias :visit_Arel_Attributes_String :visit_Arel_Attributes_Attribute_with_objectid_columns
+            alias :visit_Arel_Attributes_Time :visit_Arel_Attributes_Attribute_with_objectid_columns
+            alias :visit_Arel_Attributes_Boolean :visit_Arel_Attributes_Attribute_with_objectid_columns
+
+            attr_accessor :last_relation
+          end
+        end
+
+        def visit_BSON_ObjectId(o, a = nil)
+          column = if a then column_for(a) else last_column end
+          relation = if a then a.relation else last_relation end
+
+          raise "no column?!?" unless column
+          raise "no relation?!?" unless relation
+
+          quote(bson_objectid_value_from_parameter(o, column, relation), column)
+        end
+
+        alias_method :visit_Moped_BSON_ObjectId, :visit_BSON_ObjectId
+
+        private
+        def bson_objectid_value_from_parameter(o, column, relation)
+          column_name = column.name
+
+          manager = ObjectidColumns::ObjectidColumnsManager.for_table(relation.name)
+          unless manager
+            raise %{ObjectidColumns: You're trying to evaluate a SQL statement (in Arel, probably via ActiveRecord)
+that contains a BSON ObjectId value -- you're trying to use the value '#{o}'
+(of class #{o.class.name}) with column #{column_name.inspect} of table
+#{relation.name.inspect}. However, we can't find any record of any ObjectId
+columns being declared for that table anywhere.
+
+As a result, we don't know whether this column should be treated as a binary or
+a hexadecimal ObjectId, and hence don't know how to transform this value properly.}
+          end
+
+          unless manager.is_objectid_column?(column_name)
+            raise %{ObjectidColumns: You're trying to evaluate a SQL statement (in Arel, probably via ActiveRecord)
+that contains a BSON ObjectId value -- you're trying to use the value '#{o}'
+(of class #{o.class.name}) with column #{column_name.inspect} of table
+#{relation.name.inspect}.
+
+While we can find a record of some ObjectId columns being declared for
+that table, they don't appear to include #{column_name.inspect}. As such,
+we don't knwo whether this column should be treated as a binary or a hexadecimal
+ObjectId, and hence don't know how to transform this value properly.}
+          end
+
+          manager.to_valid_value_for_column(column_name, o)
+        end
+      end
+    end
+  end
+end

data/lib/objectid_columns/has_objectid_columns.rb

@@ -25,7 +25,7 @@ module ObjectidColumns
     # Called as a +before_create+ hook, if (and only if) this class has declared +has_objectid_primary_key+ -- sets
     # the primary key to a newly-generated ObjectId, unless it has one already.
     def assign_objectid_primary_key
-      self.id ||= ObjectidColumns.new_objectid
+      self.class.objectid_columns_manager.assign_objectid_primary_key(self)
     end
 
     module ClassMethods

data/lib/objectid_columns/objectid_columns_manager.rb

@@ -26,6 +26,128 @@ module ObjectidColumns
       # methods directly on the class, for a number of very good reasons -- see the class comment on
       # DynamicMethodsModule for more information.
       @dynamic_methods_module = ObjectidColumns::DynamicMethodsModule.new(active_record_class, :ObjectidColumnsDynamicMethods)
+
+      self.class.register_for_table(active_record_class.table_name, self)
+    end
+
+    class << self
+      # ObjectidColumns::Arel::Visitors::ToSql needs to be able to figure out whether an ObjectId column is of binary
+      # or text format, in order to properly transform/quote the value it has. However, by the time the code gets there,
+      # we no longer have access to the ActiveRecord model at all. So, instead, we need an entry point to be able to
+      # find the ObjectidColumnsManager for a table by name. That's .for_table, below; this is the method called at
+      # the end of the constructor of every ObjectidColumnsManager, registering the instance by table name.
+      def register_for_table(table_name, instance)
+        @_registered_instances ||= { }
+        @_registered_instances[table_name] = instance
+      end
+
+      # See above. Given a table name, this returns the ObjectidColumnsManager for it, or +nil+ if none has been
+      # defined for that table.
+      def for_table(table_name)
+        @_registered_instances[table_name]
+      end
+    end
+
+    # This method basically says: does our +active_record_class+ have a primary key defined, for real? There are two
+    # reasons this is anything more than (<tt>!! active_record_class.primary_key</tt>):
+    #
+    # * In earlier versions of ActiveRecord (like 3.0.x), this will return +id+ even if you haven't set it and there is
+    #   no column named +id+.
+    # * The +composite_primary_keys+ gem can make this an array instead.
+    def activerecord_class_has_no_real_primary_key?
+      (! active_record_class.primary_key) ||
+        (active_record_class.primary_key == [ ]) ||
+        ( ([ [ 'id' ], [ :id ] ].include?(Array(active_record_class.primary_key))) &&
+          (! active_record_class.columns_hash.has_key?('id')) &&
+          (! active_record_class.columns_hash.has_key?(:id)))
+    end
+
+    # If you haven't specified a primary key on your model (using <tt>self.primary_key=</tt>), and you call
+    # +has_objectid_primary_key+, we want to tell the ActiveRecord model that that's the new primary key. This takes
+    # care of that, and handles the fact that this may be a composite primary key, too.
+    def set_primary_key_from!(primary_keys)
+      if primary_keys.length > 1
+        active_record_class.primary_key = primary_keys.map(&:to_s)
+      elsif primary_keys.length == 1
+        active_record_class.primary_key = primary_keys[0].to_s
+      else
+        # nothing here; we handle this elsewhere
+      end
+    end
+
+    # Assigns a new ObjectId primary key to a brand-new model that's about to be created, if needed. This handles
+    # composite primary keys correctly.
+    def assign_objectid_primary_key(model)
+      Array(model.class.primary_key).each do |pk_column|
+        if is_objectid_column?(pk_column) && model[pk_column].blank?
+          model.send("#{pk_column}=", ObjectidColumns.new_objectid)
+        end
+      end
+    end
+
+    # Given a model, returns the correct value for #id. This takes into account composite primary keys where some
+    # columns may be ObjectId columns and some may not.
+    def read_objectid_primary_key(model)
+      pks = Array(model.class.primary_key)
+      out = [ ]
+      pks.each do |pk_column|
+        out << if is_objectid_column?(pk_column)
+          read_objectid_column(model, pk_column)
+        else
+          model[pk_column]
+        end
+      end
+      out = out[0] if out.length == 1
+      out
+    end
+
+    # Given a model, stores a new value for #id. This takes into account composite primary keys where some
+    # columns may be ObjectId columns and some may not.
+    def write_objectid_primary_key(model, new_value)
+      pks = Array(model.class.primary_key)
+      if pks.length == 1
+        write_objectid_column(model, pks[0], new_value)
+      else
+        pks.each_with_index do |pk_column, index|
+          value = new_value[index]
+          if is_objectid_column?(pk_column)
+            write_objectid_column(model, pk_column, value)
+          else
+            model[pk_column] = value
+          end
+        end
+      end
+    end
+
+    # Implements .find or .find_by_id for classes that have a primary key that has at least one ObjectId column in it;
+    # this takes care of handling both normal primary keys and composite primary keys.
+    def find_or_find_by_id(*args)
+      primary_key = active_record_class.primary_key
+      pk_length = primary_key.kind_of?(Array) ? primary_key.length : 1
+
+      # If we just have a single primary key, we flatten any input, just because that's exactly what base
+      # ActiveRecord does...
+      if pk_length == 1
+        args = args.flatten
+        args = args.map { |x| to_valid_value_for_column(primary_key, x) if x }
+        yield(*args)
+      else
+        # composite_primary_keys, however, requires that you pass each key as a single, separate argument to .find or
+        # .find_by_id; we transform them here.
+        keys = args.map do |key|
+          new_key = [ ]
+          key.each_with_index do |key_component, index|
+            column = primary_key[index]
+            new_key << if is_objectid_column?(column)
+              to_valid_value_for_column(column, key_component) if key_component
+            else
+              key_component
+            end
+          end
+          new_key
+        end
+        yield(*keys)
+      end
     end
 
     # Declares that this class is using an ObjectId as its primary key. Ordinarily, this requires no arguments;
@@ -37,40 +159,52 @@ module ObjectidColumns
     # ObjectIds are safe to generate client-side, and very difficult to properly generate server-side in a relational
     # database. However, we will respect (and not overwrite) any primary key already assigned to the record before it's
     # saved, so if you want to assign your own ObjectId primary keys, you can.
-    def has_objectid_primary_key(primary_key_name = nil)
-      # The Symbol-vs.-String distinction is critical when dealing with old versions of ActiveRecord; for example, if
-      # you say <tt>self.primary_key = :foo</tt> (instead of <tt>self.primary_key = 'foo'</tt>) to older versions of
-      # ActiveRecord, you can end up with some seriously weird errors later (like models trying to save themselves with
-      # _both_ a +:foo+ and a +'foo'+ attribute -- ick!). Boo, AR.
-      primary_key_name = primary_key_name.to_s if primary_key_name
-      pk = active_record_class.primary_key
-
-      # Make sure we know what the primary key is!
-      if (! pk) && (! primary_key_name)
-        raise ArgumentError, "Class #{active_record_class.name} has no primary key set, and you haven't supplied one to .has_objectid_primary_key. Either set one before this call (using self.primary_key = :foo), or supply one to this call (has_objectid_primary_key :foo) and we'll set it for you."
+    #
+    # This method handles composite primary keys, as provided by the +composite_primary_keys+ gem, correctly.
+    def has_objectid_primary_key(*primary_keys_that_are_objectid_columns)
+      # First, normalize our set of primary keys that are ObjectId columns...
+      primary_keys_that_are_objectid_columns = primary_keys_that_are_objectid_columns.compact.map(&:to_s).uniq
+
+      # Now, see what all the primary keys are. If the user hasn't specified any primary keys on the class at all yet,
+      # but has told us what they are, then we need to tell ActiveRecord what they are.
+      all_primary_keys = if activerecord_class_has_no_real_primary_key?
+        set_primary_key_from!(primary_keys_that_are_objectid_columns)
+        primary_keys_that_are_objectid_columns
+      else
+        Array(active_record_class.primary_key)
       end
+      # Normalize the set of all primary keys.
+      all_primary_keys = all_primary_keys.compact.map(&:to_s).uniq
 
-      pk = pk.to_s if pk
+      # Let's make sure we have a primary key...
+      raise ArgumentError, "Class #{active_record_class.name} has no primary key set, and you haven't supplied one to #has_objectid_primary_key" if all_primary_keys.empty?
 
-      # Initially, this was a simple +||=+ statement. However, older versions of ActiveRecord will return the string or
-      # symbol +id+ for the primary key if you haven't set an explicit primary key, even if there is no such column on
-      # the underlying table. Again, ick.
-      if (! pk) || (primary_key_name && pk.to_s != primary_key_name.to_s)
-        active_record_class.primary_key = pk = primary_key_name
+      # If you didn't specify any ObjectId columns explicitly, use what we know about the class to figure out which
+      # ones you mean.
+      if primary_keys_that_are_objectid_columns.empty?
+        if all_primary_keys.length == 1
+          primary_keys_that_are_objectid_columns = all_primary_keys
+        else
+          primary_keys_that_are_objectid_columns = autodetect_columns_from(all_primary_keys, true)
+        end
       end
 
-      # In case someone is using composite_primary_keys (http://compositekeys.rubyforge.org/).
-      raise "You can't have an ObjectId primary key that's not a String or Symbol: #{pk.inspect}" unless pk.kind_of?(String) || pk.kind_of?(Symbol)
+      # Make sure we have at least one ObjectId primary key, if we're in this method.
+      raise "Class #{active_record_class.name} has no columns in its primary key that qualify as object IDs automatically; you must specify their names explicitly." if primary_keys_that_are_objectid_columns.empty?
+
+      # Make sure all the columns the user named actually exist as columns on the model.
+      missing = primary_keys_that_are_objectid_columns.select { |c| ! active_record_class.columns_hash.has_key?(c) }
+      raise "The following primary-key column(s) do not appear to actually exist on #{active_record_class.name}: #{missing.inspect}; we have these columns: #{active_record_class.columns_hash.keys.inspect}" unless missing.empty?
 
       # Declare our primary-key column as an ObjectId column.
-      has_objectid_column pk
-
-      # If it's not called just "id", we need to explicitly define an "id" method that correctly reads from and writes
-      # to the table.
-      unless pk.to_s == 'id'
-        p = pk
-        dynamic_methods_module.define_method("id") { read_objectid_column(p) }
-        dynamic_methods_module.define_method("id=") { |new_value| write_objectid_column(p, new_value) }
+      has_objectid_column *primary_keys_that_are_objectid_columns
+
+      # Override #id and #id= to do the right thing...
+      dynamic_methods_module.define_method("id") do
+        self.class.objectid_columns_manager.read_objectid_primary_key(self)
+      end
+      dynamic_methods_module.define_method("id=") do |new_value|
+        self.class.objectid_columns_manager.write_objectid_primary_key(self, new_value)
       end
 
       # Allow us to autogenerate the primary key, if needed, on save.
@@ -79,17 +213,7 @@ module ObjectidColumns
       # Override a couple of methods that, if you're using an ObjectId column as your primary key, need overriding. ;)
       [ :find, :find_by_id ].each do |class_method_name|
         @dynamic_methods_module.define_class_method(class_method_name) do |*args, &block|
-          if args.length == 1 && args[0].kind_of?(String) || ObjectidColumns.is_valid_bson_object?(args[0]) || args[0].kind_of?(Array)
-            args[0] = if args[0].kind_of?(Array)
-              args[0].map { |x| objectid_columns_manager.to_valid_value_for_column(primary_key, x) if x }
-            else
-              objectid_columns_manager.to_valid_value_for_column(primary_key, args[0]) if args[0]
-            end
-
-            super(args[0], &block)
-          else
-            super(*args, &block)
-          end
+          objectid_columns_manager.find_or_find_by_id(*args) { |*new_args| super(*new_args, &block) }
         end
       end
     end
@@ -104,7 +228,7 @@ module ObjectidColumns
       return unless active_record_class.table_exists?
 
       # Autodetect columns ending in +_oid+ if needed
-      columns = autodetect_columns if columns.length == 0
+      columns = autodetect_columns_from(active_record_class.columns_hash.keys) if columns.length == 0
 
       columns = columns.map { |c| c.to_s.strip.downcase.to_sym }
       columns.each do |column_name|
@@ -150,10 +274,11 @@ module ObjectidColumns
       column_name = column_name.to_s
       value = model[column_name]
       return value unless value # in case it's nil
+      return value if ObjectidColumns.is_valid_bson_object?(value) # we can get this when reading the 'id' pseudocolumn
 
       # If it's not nil, the database should always be giving us back a String...
       unless value.kind_of?(String)
-        raise "When trying to read the ObjectId column #{column_name.inspect} on #{inspect},  we got the following data from the database; we expected a String: #{value.inspect}"
+        raise "When trying to read the ObjectId column #{column_name.inspect} on #{active_record_class.name} ID=#{model.id.inspect}, we got the following data from the database; we expected a String: #{value.inspect}"
       end
 
       # ugh...ActiveRecord 3.1.x can return this in certain circumstances
@@ -163,7 +288,7 @@ module ObjectidColumns
       # you get back all 16 anyway, with 0x00 bytes at the end. Converting this to an ObjectId will fail, so we make
       # sure we chop those bytes off. (Note that while String#strip will, in fact, remove these bytes too, it is not
       # safe: if the ObjectId itself ends in one or more 0x00 bytes, then these will get incorrectly removed.)
-      case objectid_column_type(column_name)
+      case type = objectid_column_type(column_name)
       when :binary then value = value[0..(BINARY_OBJECTID_LENGTH - 1)]
       when :string then value = value[0..(STRING_OBJECTID_LENGTH - 1)]
       else unknown_type(type)
@@ -252,6 +377,11 @@ module ObjectidColumns
       end
     end
 
+    # Given the name of a column, tell whether or not it is an ObjectId column.
+    def is_objectid_column?(column_name)
+      oid_columns.has_key?(column_name.to_sym)
+    end
+
     private
     attr_reader :active_record_class, :dynamic_methods_module, :oid_columns
 
@@ -282,14 +412,18 @@ module ObjectidColumns
 
     # If someone called +has_objectid_columns+ but didn't pass an argument, this method detects which columns we should
     # automatically turn into ObjectId columns -- which means any columns ending in +_oid+, except for the primary key.
-    def autodetect_columns
-      out = active_record_class.columns.select { |c| c.name =~ /_oid$/i }.map(&:name).map(&:to_s)
+    def autodetect_columns_from(column_names, allow_primary_key = false)
+      column_names = column_names.map(&:to_s)
+      out = column_names.select do |column_name|
+        column = active_record_class.columns_hash[column_name]
+        column && column.name =~ /_oid$/i
+      end
 
       # Make sure we never, ever automatically make the primary-key column an ObjectId column.
-      out -= [ active_record_class.primary_key ].compact.map(&:to_s)
+      out -= Array(active_record_class.primary_key).compact.map(&:to_s) unless allow_primary_key
 
       unless out.length > 0
-        raise ArgumentError, "You didn't pass in the names of any ObjectId columns, and we couldn't find any columns ending in _oid to pick up automatically (primary key is always excluded). Either name some columns explicitly, or remove the has_objectid_columns call."
+        raise ArgumentError, "You didn't pass in the names of any ObjectId columns, and we couldn't find any columns ending in _oid to pick up automatically (primary key is always excluded). Either name some columns explicitly, or remove the has_objectid_columns call. We found columns named: #{column_names.inspect}"
       end
 
       out

data/lib/objectid_columns/version.rb

@@ -1,4 +1,4 @@
 # What's the current version of this gem?
 module ObjectidColumns
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/objectid_columns.gemspec

@@ -48,4 +48,24 @@ Gem::Specification.new do |spec|
   else
     spec.add_development_dependency(database_gem_name)
   end
+
+  # Double ugh. Basically, composite_primary_keys -- as useful as it is! -- is also incredibly incompatible with so
+  # much stuff:
+  #
+  # * Under Ruby 1.9+ with Postgres, it causes binary strings sent to or from the database to get truncated
+  #   at the first null byte (!), which completely breaks binary-column support;
+  # * Under JRuby with ActiveRecord 3.0, it's completely broken;
+  # * Under JRuby with ActiveRecord 3.1 and PostgreSQL, it's also broken.
+  #
+  # In these cases, we simply don't load or test against composite_primary_keys; our code is good, but the interactions
+  # between CPK and the rest of the system make it impossible to run those tests. There is corresponding code in our
+  # +basic_system_spec+ to exclude those combinations.
+  cpk_allowed = true
+  cpk_allowed = false if database_gem_name =~ /(pg|postgres)/i && RUBY_VERSION =~ /^(1\.9)|(2\.)/ && ar_version && ar_version =~ /^4\.0\./
+  cpk_allowed = false if defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'jruby') && ar_version && ar_version =~ /^3\.0\./
+  cpk_allowed = false if defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'jruby') && ar_version && ar_version =~ /^3\.1\./ && database_gem_name =~ /(pg|postgres)/i
+
+  if cpk_allowed
+    spec.add_development_dependency "composite_primary_keys"
+  end
 end

data/spec/objectid_columns/system/basic_system_spec.rb

@@ -1,6 +1,16 @@
 require 'objectid_columns'
 require 'objectid_columns/helpers/system_helpers'
 
+# See the gemspec for more details -- basically, we don't always load composite_primary_keys, because it's pretty
+# broken and doesn't work with a fair number of combinations of Ruby versions, databases, and so on. So if it's not
+# available, we skip those tests.
+begin
+  require 'composite_primary_keys'
+  $composite_primary_keys_available = true
+rescue LoadError => le
+  # nothing here
+end
+
 unless defined?(VALID_OBJECTID_CLASSES)
   VALID_OBJECTID_CLASSES = [ BSON::ObjectId ]
   VALID_OBJECTID_CLASSES << Moped::BSON::ObjectId if defined?(Moped::BSON::ObjectId)
@@ -81,6 +91,115 @@ describe "ObjectidColumns basic operations" do
         expect { ::SpectableNonexistent.class_eval { has_objectid_column :foo } }.to_not raise_error
       end
 
+      if $composite_primary_keys_available
+        describe "composite primary key support" do
+          context "with an implicit PK" do
+            before :each do
+              migrate do
+                drop_table :objectidcols_spec_pk_cmp rescue nil
+                create_table :objectidcols_spec_pk_cmp, :id => false do |t|
+                  t.binary :some_oid, :null => false
+                  t.string :more_pk, :null => false
+                  t.string :value
+                end
+              end
+
+              define_model_class(:SpectablePkCmp, :objectidcols_spec_pk_cmp) do
+                if respond_to?(:primary_keys=)
+                  self.primary_keys = [ 'some_oid', 'more_pk' ]
+                else
+                  self.set_primary_keys('some_oid', 'more_pk')
+                end
+              end
+              ::SpectablePkCmp.class_eval { has_objectid_primary_key }
+              @model_class = ::SpectablePkCmp
+            end
+
+            it "should allow using a composite primary key in individual parts" do
+              pending "disabled" unless $composite_primary_keys_available
+
+              instance = @model_class.new
+              instance.some_oid = new_oid
+              instance.more_pk = "foo"
+              instance.value = "foo value"
+              instance.save!
+
+              instance_again = @model_class.find([ instance.some_oid, instance.more_pk ])
+              expect(instance_again.value).to eq(instance.value)
+              expect(instance_again.some_oid).to eq(instance.some_oid)
+              expect(instance_again.more_pk).to eq(instance.more_pk)
+            end
+
+            it "should allow using a composite primary key as a whole" do
+              pending "disabled" unless $composite_primary_keys_available
+
+              oid = new_oid
+              instance = @model_class.new
+              instance.id = [ oid, "foo" ]
+              instance.value = "foo value"
+              instance.save!
+
+              expect(instance.some_oid).to be_an_objectid_object_matching(oid)
+              expect(instance.more_pk).to eq("foo")
+              expect(instance.value).to eq("foo value")
+
+              instance_again = @model_class.find(instance.id)
+              expect(instance_again.id).to eq(instance.id)
+              expect(instance_again.some_oid).to be_an_objectid_object_matching(oid)
+              expect(instance_again.more_pk).to eq("foo")
+              expect(instance_again.value).to eq("foo value")
+              expect(instance_again.id).to be_kind_of(Array)
+              expect(instance_again.id.length).to eq(2)
+              expect(instance_again.id[0]).to be_an_objectid_object_matching(oid)
+              expect(instance_again.id[1]).to eq("foo")
+            end
+          end
+
+          context "with an explicit PK" do
+            before :each do
+              migrate do
+                drop_table :objectidcols_spec_pk_cmp_2 rescue nil
+                create_table :objectidcols_spec_pk_cmp_2, :id => false do |t|
+                  t.binary :one, :null => false
+                  t.string :two, :null => false
+                  t.string :three, :null => false
+                  t.string :value
+                end
+              end
+
+              define_model_class(:SpectablePkCmp2, :objectidcols_spec_pk_cmp_2) do
+                if respond_to?(:primary_keys=)
+                  self.primary_keys = [ 'one', 'two', 'three' ]
+                else
+                  self.set_primary_keys('one', 'two', 'three')
+                end
+              end
+              ::SpectablePkCmp2.class_eval { has_objectid_primary_key :one, :three }
+              @model_class = ::SpectablePkCmp2
+            end
+
+            it "should allow using a composite primary key that's partially ObjectId and partially not" do
+              instance = @model_class.new
+              instance.two = "foo"
+              instance.value = "foo_value"
+              instance.save!
+
+              expect(instance.id).to be_kind_of(Array)
+              expect(instance.id[0]).to be_an_objectid_object
+              expect(instance.id[1]).to eq("foo")
+              expect(instance.id[2]).to be_an_objectid_object
+
+              id = instance.id
+              instance_again = @model_class.find(id)
+              expect(instance_again.id).to eq(id)
+              expect(instance_again.id[0]).to be_an_objectid_object_matching(id[0])
+              expect(instance_again.id[1]).to eq("foo")
+              expect(instance_again.id[2]).to be_an_objectid_object_matching(id[2])
+            end
+          end
+        end
+      end
+
       describe "primary key column support" do
         before :each do
           migrate do
@@ -174,6 +293,22 @@ describe "ObjectidColumns basic operations" do
               expect(@model_class.send(find_by_id_method, new_oid)).to be_nil
             end
 
+            it "should let you load and save objects properly" do
+              r1 = @model_class.new
+              r1.name = 'row 1'
+              r1.id = new_oid
+              r1.save!
+
+              r1_again = @model_class.find(@tc.from_string(r1.id.to_s))
+              expect(r1_again.name).to eq('row 1')
+              r1_again.id = @tc.from_string(r1.id.to_s)
+              r1_again.name = 'row 1 again'
+              r1_again.save!
+
+              r1_yet_again = @model_class.find(r1_again.id)
+              expect(r1_yet_again.name).to eq('row 1 again')
+            end
+
             it "should not pick up primary-key columns automatically, even if they're named _oid" do
               migrate do
                 drop_table :objectidcols_spec_pk_auto rescue nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: objectid_columns
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Andrew Geweke
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-01-31 00:00:00 Z
+date: 2014-03-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -86,6 +86,14 @@ dependencies:
     - *id007
   type: :development
   version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: composite_primary_keys
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id007
+  type: :development
+  version_requirements: *id009
 description: 
 email: 
 - ageweke@swiftype.com
@@ -98,6 +106,7 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - .travis.yml
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -105,6 +114,7 @@ files:
 - lib/objectid_columns.rb
 - lib/objectid_columns/active_record/base.rb
 - lib/objectid_columns/active_record/relation.rb
+- lib/objectid_columns/arel/visitors/to_sql.rb
 - lib/objectid_columns/dynamic_methods_module.rb
 - lib/objectid_columns/extensions.rb
 - lib/objectid_columns/has_objectid_columns.rb