globe-composite_primary_keys 3.0.1

data/lib/composite_primary_keys/attribute_methods.rb

@@ -0,0 +1,84 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module AttributeMethods #:nodoc:
+      def self.append_features(base)
+        super
+        base.send(:extend, ClassMethods)
+      end
+
+      module ClassMethods
+        # Define an attribute reader method.  Cope with nil column.
+        def define_read_method(symbol, attr_name, column)
+          cast_code = column.type_cast_code('v') if column
+          cast_code = "::#{cast_code}" if cast_code && cast_code.match('ActiveRecord::.*')
+          access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
+
+          unless self.primary_keys.include?(attr_name.to_sym)
+            access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+          end
+
+          if cache_attribute?(attr_name)
+            access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
+          end
+
+          evaluate_attribute_method attr_name, "def #{symbol}; #{access_code}; end"
+        end
+
+        # Evaluate the definition for an attribute related method
+        def evaluate_attribute_method(attr_name, method_definition, method_name=attr_name)
+          unless primary_keys.include?(method_name.to_sym)
+            generated_methods << method_name
+          end
+
+          begin
+            class_eval(method_definition, __FILE__, __LINE__)
+          rescue SyntaxError => err
+            generated_methods.delete(attr_name)
+            if logger
+              logger.warn "Exception occurred during reader method compilation."
+              logger.warn "Maybe #{attr_name} is not a valid Ruby identifier?"
+              logger.warn "#{err.message}"
+            end
+          end
+        end
+      end
+
+      # Allows access to the object attributes, which are held in the @attributes hash, as though they
+      # were first-class methods. So a Person class with a name attribute can use Person#name and
+      # Person#name= and never directly use the attributes hash -- except for multiple assigns with
+      # ActiveRecord#attributes=. A Milestone class can also ask Milestone#completed? to test that
+      # the completed attribute is not nil or 0.
+      #
+      # It's also possible to instantiate related objects, so a Client class belonging to the clients
+      # table with a master_id foreign key can instantiate master through Client#master.
+      def method_missing(method_id, *args, &block)
+        method_name = method_id.to_s
+
+        # If we haven't generated any methods yet, generate them, then
+        # see if we've created the method we're looking for.
+        if !self.class.generated_methods?
+          self.class.define_attribute_methods
+
+          if self.class.generated_methods.include?(method_name)
+            return self.send(method_id, *args, &block)
+          end
+        end
+
+        if self.class.primary_keys.include?(method_name.to_sym)
+          ids[self.class.primary_keys.index(method_name.to_sym)]
+        elsif md = self.class.match_attribute_method?(method_name)
+          attribute_name, method_type = md.pre_match, md.to_s
+          if @attributes.include?(attribute_name)
+            __send__("attribute#{method_type}", attribute_name, *args, &block)
+          else
+            super
+          end
+        elsif @attributes.include?(method_name)
+          read_attribute(method_name)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/base.rb

@@ -0,0 +1,200 @@
+module ActiveRecord
+  class CompositeKeyError < StandardError #:nodoc:
+  end
+
+  class Base
+    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
+    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
+
+    class << self
+      def set_primary_keys(*keys)
+        keys = keys.first if keys.first.is_a?(Array)
+
+        if keys.length == 1
+          set_primary_key(keys.first)
+          return
+        end
+
+        cattr_accessor :primary_keys
+        self.primary_keys = keys.map { |k| k.to_sym }
+
+        class_eval <<-EOV
+          extend CompositeClassMethods
+          include CompositeInstanceMethods
+          include CompositePrimaryKeys::ActiveRecord::AssociationPreload
+        EOV
+
+        class << unscoped
+          include CompositePrimaryKeys::ActiveRecord::FinderMethods::InstanceMethods
+          include CompositePrimaryKeys::ActiveRecord::Relation::InstanceMethods
+        end
+      end
+
+      def composite?
+        false
+      end
+    end
+
+    def composite?
+      self.class.composite?
+    end
+
+    def [](attr_name)
+      # CPK
+      if attr_name.is_a?(String) and attr_name != attr_name.split(CompositePrimaryKeys::ID_SEP).first
+        attr_name = attr_name.split(CompositePrimaryKeys::ID_SEP)
+      end
+
+      # CPK
+      if attr_name.is_a?(Array)
+        attr_name.map {|name| read_attribute(name)}
+      else
+        read_attribute(attr_name)
+      end
+    end
+
+    def []=(attr_name, value)
+      # CPK
+      if attr_name.is_a?(String) and attr_name != attr_name.split(CompositePrimaryKeys::ID_SEP).first
+        attr_name = attr_name.split(CompositePrimaryKeys::ID_SEP)
+      end
+
+      if attr_name.is_a? Array
+        unless value.length == attr_name.length
+          raise "Number of attr_names and values do not match"
+        end
+        [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
+        value
+      else
+         write_attribute(attr_name, value)
+      end
+    end
+    
+    module CompositeClassMethods
+      def primary_key
+        primary_keys
+      end
+
+      def primary_key=(keys)
+        primary_keys = keys
+      end
+
+      def composite?
+        true
+      end
+
+      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
+      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
+      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
+        many_ids.map {|ids| "#{left_bracket}#{ids}#{right_bracket}"}.join(list_sep)
+      end
+    end
+
+    module CompositeInstanceMethods
+      # A model instance's primary keys is always available as model.ids
+      # whether you name it the default 'id' or set it to something else.
+      def id
+        attr_names = self.class.primary_keys
+        CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
+      end
+      alias_method :ids, :id
+
+      def ids_hash
+        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
+          hash[key] = value
+          hash
+        end
+      end
+
+      def to_param
+        id.to_s
+      end
+
+      def id_before_type_cast #:nodoc:
+        raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::NOT_IMPLEMENTED_YET
+      end
+
+      def quoted_id #:nodoc:
+        [self.class.primary_keys, ids].
+          transpose.
+          map {|attr_name,id| quote_value(id, column_for_attribute(attr_name))}.
+          to_composite_ids
+      end
+
+      # Sets the primary ID.
+      def id=(ids)
+        ids = ids.split(CompositePrimaryKeys::ID_SEP) if ids.is_a?(String)
+        ids.flatten!
+        unless ids.is_a?(Array) and ids.length == self.class.primary_keys.length
+          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
+        end
+        [primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
+        id
+      end
+
+      def update_attribute(name, value)
+        raise ActiveRecordError, "#{name.to_s} is marked as readonly" if self.class.readonly_attributes.include? name.to_s
+
+        changes = {}
+
+        if name
+          name = name.to_s
+          send("#{name}=", value)
+          changes[name] = read_attribute(name)
+        end
+
+        @changed_attributes.except!(*changes.keys)
+        self.class.update_all(changes, ids_hash) == 1
+      end
+
+      # Cloned objects have no id assigned and are treated as new records. Note that this is a "shallow" clone
+      # as it copies the object's attributes only, not its associations. The extent of a "deep" clone is
+      # application specific and is therefore left to the application to implement according to its need.
+      def initialize_copy(other)
+        # Think the assertion which fails if the after_initialize callback goes at the end of the method is wrong. The
+        # deleted clone method called new which therefore called the after_initialize callback. It then went on to copy
+        # over the attributes. But if it's copying the attributes afterwards then it hasn't finished initializing right?
+        # For example in the test suite the topic model's after_initialize method sets the author_email_address to
+        # test@test.com. I would have thought this would mean that all cloned models would have an author email address
+        # of test@test.com. However the test_clone test method seems to test that this is not the case. As a result the
+        # after_initialize callback has to be run *before* the copying of the atrributes rather than afterwards in order
+        # for all tests to pass. This makes no sense to me.
+        callback(:after_initialize) if respond_to_without_attributes?(:after_initialize)
+        cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
+        # CPK
+        #cloned_attributes.delete(self.class.primary_key)
+        self.class.primary_key.each {|key| cloned_attributes.delete(key.to_s)}
+
+        @attributes = cloned_attributes
+        clear_aggregation_cache
+        @attributes_cache = {}
+        @new_record = true
+        ensure_proper_type
+
+        if scope = self.class.send(:current_scoped_methods)
+          create_with = scope.scope_for_create
+          create_with.each { |att,value| self.send("#{att}=", value) } if create_with
+        end
+      end
+
+      def destroy
+        if persisted?
+          # CPK
+          # self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).delete_all
+          self.class.unscoped.where(ids_hash).delete_all
+        end
+
+        @destroyed = true
+        freeze
+      end
+
+      def update(attribute_names = @attributes.keys)
+        attributes_with_values = arel_attributes_values(false, false, attribute_names)
+        return 0 if attributes_with_values.empty?
+        # CPK
+        # self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
+        self.class.unscoped.where(ids_hash).arel.update(attributes_with_values)
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/composite_arrays.rb

@@ -0,0 +1,29 @@
+module CompositePrimaryKeys
+  ID_SEP     = ','
+  ID_SET_SEP = ';'
+
+  module ArrayExtension
+    def to_composite_keys
+      CompositeKeys.new(self)
+    end
+
+    def to_composite_ids
+      CompositeIds.new(self)
+    end
+  end
+
+  class CompositeKeys < Array
+    def to_s
+      # Doing this makes it easier to parse Base#[](attr_name)
+      join(ID_SEP)
+    end
+  end
+
+  class CompositeIds < Array
+    def to_s
+      join(ID_SEP)
+    end
+  end
+end
+
+Array.send(:include, CompositePrimaryKeys::ArrayExtension)

data/lib/composite_primary_keys/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    class AbstractAdapter
+      def concat(*columns)
+        "CONCAT(#{columns.join(',')})"
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/ibm_db_adapter.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class IBM_DBAdapter < AbstractAdapter
+      
+      # This mightn't be in Core, but count(distinct x,y) doesn't work for me
+      def supports_count_distinct? #:nodoc:
+        false
+      end
+      
+      alias_method :quote_original, :quote
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && [:integer, :float].include?(column.type)
+              value = column.type == :integer ? value.to_i : value.to_f
+              value.to_s
+        else
+            quote_original(value, column)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/oracle_adapter.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class OracleAdapter < AbstractAdapter
+      
+      # This mightn't be in Core, but count(distinct x,y) doesn't work for me
+      def supports_count_distinct? #:nodoc:
+        false
+      end
+      
+      def concat(*columns)
+        "(#{columns.join('||')})"
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/oracle_enhanced_adapter.rb

@@ -0,0 +1,17 @@
+# Added to OracleEnhancedAdapter version 1.1.4
+# 
+# module ActiveRecord
+#   module ConnectionAdapters
+#     class OracleEnhancedAdapter < AbstractAdapter
+#       
+#       # This mightn't be in Core, but count(distinct x,y) doesn't work for me
+#       def supports_count_distinct? #:nodoc:
+#         false
+#       end
+#       
+#       def concat(*columns)
+#         "(#{columns.join('||')})"
+#       end
+#     end
+#   end
+# end

data/lib/composite_primary_keys/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      
+      # This mightn't be in Core, but count(distinct x,y) doesn't work for me
+      def supports_count_distinct? #:nodoc:
+        false
+      end
+
+      def concat(*columns)
+        columns = columns.map { |c| "CAST(#{c} AS varchar)" }
+        "(#{columns.join('||')})"
+      end
+      
+      # Executes an INSERT query and returns the new record's ID
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        # Extract the table from the insert sql. Yuck.
+        table = sql.split(" ", 4)[2].gsub('"', '')
+
+        # Try an insert with 'returning id' if available (PG >= 8.2)
+        if supports_insert_with_returning?
+          pk, sequence_name = *pk_and_sequence_for(table) unless pk
+          if pk
+            quoted_pk = if pk.is_a?(Array)
+                          pk.map { |col| quote_column_name(col) }.join(CompositePrimaryKeys::ID_SEP)
+                        else
+                          quote_column_name(pk)
+                        end
+            id = select_value("#{sql} RETURNING #{quoted_pk}")
+            clear_query_cache
+            return id
+          end
+        end
+
+        # Otherwise, insert then grab last_insert_id.
+        if insert_id = super
+          insert_id
+        else
+          # If neither pk nor sequence name is given, look them up.
+          unless pk || sequence_name
+            pk, sequence_name = *pk_and_sequence_for(table)
+          end
+
+          # If a pk is given, fallback to default sequence name.
+          # Don't fetch last insert id for a table without a pk.
+          if pk && sequence_name ||= default_sequence_name(table, pk)
+            last_insert_id(table, sequence_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,15 @@
+require 'active_record/connection_adapters/sqlite_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    class SQLite3Adapter < SQLiteAdapter # :nodoc:
+      def supports_count_distinct? #:nodoc:
+        false
+      end
+      
+      def concat(*columns)
+        "(#{columns.join('||')})"
+      end
+    end
+  end
+end