composite_primary_keys 0.1.3

data/CHANGELOG

@@ -0,0 +1,8 @@
+* 0.0.1 * Initial version
+ - set_primary_keys(*keys) is the activation class method to transform an ActiveRecord into
+ 		a composite primary key AR
+ - find(*ids) supports the passing of 
+ 		- id sets: Foo.find(2,1), 
+ 		- lists of id sets: Foo.find([2,1], [7,3], [8,12]), 
+ 		- and even stringified versions of the above:
+ 		- Foo.find '2,1' or Foo.find '2,1;7,3'

data/Rakefile

@@ -0,0 +1,177 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require File.join(File.dirname(__FILE__), 'lib', 'composite_primary_keys', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'composite_primary_keys'
+PKG_VERSION   = CompositePrimayKeys::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "compositekeys"
+RUBY_FORGE_USER    = "nicwilliams"
+
+PKG_FILES = FileList[
+    "lib/**/*", "test/**/*", "examples/**/*", "doc/**/*", "[A-Z]*", "install.rb", "Rakefile"
+].exclude(/\bCVS\b|~$/)
+
+
+desc "Default Task"
+task :default => [ :test_mysql ] # UNTESTED =, :test_sqlite, :test_postgresql ]
+
+# Run the unit tests
+
+for adapter in %w( mysql ) # UNTESTED - postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oracle sybase openbase )
+  Rake::TestTask.new("test_#{adapter}") { |t|
+    t.libs << "test" << "test/connections/native_#{adapter}"
+    t.pattern = "test/*_test{,_#{adapter}}.rb"
+    t.verbose = true
+  }
+end
+
+SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))
+
+desc 'Build the MySQL test databases'
+task :build_mysql_databases => [:drop_mysql_databases] do 
+  puts File.join(SCHEMA_PATH, 'mysql.sql')
+  %x( mysqladmin -u root create activerecord_unittest )
+  #%x( mysqladmin  -u root create activerecord_unittest2 )
+  %x( mysql -u root activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql.sql')} )
+  #%x( mysql -u root activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql2.sql')} )
+end
+
+desc 'Drop the MySQL test databases'
+task :drop_mysql_databases do 
+  %x( mysqladmin -u root -f drop activerecord_unittest )
+  #%x( mysqladmin -u root -f drop activerecord_unittest2 )
+end
+
+desc 'Rebuild the MySQL test databases'
+task :rebuild_mysql_databases => [:drop_mysql_databases, :build_mysql_databases]
+
+desc 'Build the PostgreSQL test databases'
+task :build_postgresql_databases do 
+  %x( createdb activerecord_unittest )
+  %x( createdb activerecord_unittest2 )
+  %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} )
+  %x( psql activerecord_unittest2 -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')} )
+end
+
+desc 'Drop the PostgreSQL test databases'
+task :drop_postgresql_databases do 
+  %x( dropdb   activerecord_unittest )
+  %x( dropdb   activerecord_unittest2 )
+end
+
+desc 'Rebuild the PostgreSQL test databases'
+task :rebuild_postgresql_databases => [:drop_postgresql_databases, :build_postgresql_databases]
+
+# Generate the RDoc documentation
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Composite Primary Keys -- Composite keys for Active Records/Rails"
+  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README', 'CHANGELOG')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.exclude('lib/active_record/vendor/*')
+  rdoc.rdoc_files.include('dev-utils/*.rb')
+}
+
+# Enhance rdoc task to copy referenced images also
+task :rdoc do
+  FileUtils.mkdir_p "doc/files/examples/"
+end
+
+
+# Create compressed packages
+
+dist_dirs = [ "lib", "test", "examples", "dev-utils" ]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Support for composite primary keys in ActiveRecords"
+  s.description = %q{ActiveRecords only support a single primary key, preventing their use on legacy databases where tables have primary keys over 2+ columns. This solution allows an ActiveRecord to be extended to support multiple keys using the class method set_primary_keys.}
+
+  s.files = [ "Rakefile", "install.rb", "README", "CHANGELOG" ]
+  dist_dirs.each do |dir|
+    s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  end
+  
+  s.add_dependency('activerecord', '= 1.14.3' + PKG_BUILD)
+
+  s.require_path = 'lib'
+  s.autorequire = 'composite_primary_keys'
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = %w( README )
+  s.rdoc_options.concat ['--main',  'README']
+  
+  s.author = "Dr Nic Williams"
+  s.email = "drnicwilliams@gmail.com"
+  s.homepage = "http://composite_primary_keys.rubyforge.org"
+  s.rubyforge_project = "composite_primary_keys"
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = false
+  p.need_zip = false
+end
+
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/composite_primary_keys/**/*.rb"]
+    next if file_name =~ /vendor/
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+    
+    total_lines     += lines
+    total_codelines += codelines
+    
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
+
+# Publishing ------------------------------------------------------
+
+desc "Publish the beta gem"
+task :pgem => [:package] do 
+  Rake::SshFilePublisher.new("drnicwilliams@gmail.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh drnicwilliams@gmail.com './gemupdate.sh'`
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  Rake::SshDirPublisher.new("drnicwilliams@gmail.com", "public_html/ar", "doc").upload
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  `ruby scripts/rubyforge login`
+
+  for ext in %w( gem tgz zip )
+    release_command = "ruby scripts/rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}"
+    puts release_command
+    system(release_command)
+  end
+end

data/install.rb

@@ -0,0 +1,30 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+# this was adapted from rdoc's install.rb by ways of Log4r
+
+$sitedir = CONFIG["sitelibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/ }
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+# the acual gruntwork
+Dir.chdir("lib")
+
+Find.find("composite_primary_keys", "composite_primary_keys.rb") { |f|
+  if f[-3..-1] == ".rb"
+    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
+  else
+    File::makedirs(File.join($sitedir, *f.split(/\//)))
+  end
+}

data/lib/composite_primary_keys.rb

@@ -0,0 +1,41 @@
+#--
+# Copyright (c) 2006 Nic Williams
+#
+# 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.
+#++
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+unless defined?(ActiveRecord)
+  begin
+    $:.unshift(File.dirname(__FILE__) + "/../../activerecord/lib")  
+    require 'active_record'  
+  rescue LoadError
+    require 'rubygems'
+    require_gem 'activerecord'
+  end
+end
+
+require 'composite_primary_keys/base'
+
+ActiveRecord::Base.class_eval do
+  include CompositePrimayKeys::ActiveRecord::Base
+end

data/lib/composite_primary_keys/base.rb

@@ -0,0 +1,219 @@
+module CompositePrimayKeys
+  module ActiveRecord #:nodoc:
+    module Base #:nodoc:
+
+      INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
+      ID_SEP = ','
+       
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+      end
+    
+      module ClassMethods
+        def set_primary_keys(*keys)
+          @@primary_keys = []
+          cattr_accessor :primary_keys 
+          self.primary_keys = keys
+          
+          class_eval <<-EOV
+            include CompositePrimayKeys::ActiveRecord::Base::InstanceMethods
+            extend CompositePrimayKeys::ActiveRecord::Base::CompositeClassMethods
+          EOV
+        end
+      end
+     
+      module InstanceMethods  
+        
+        # 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
+          attr_names.map {|attr_name| read_attribute(attr_name)}
+        end
+        alias_method :ids, :id
+        
+        #id_to_s([1,2]) -> "1,2"
+        #id_to_s([1,2], '-') -> "1-2"
+        def id_to_s(ids, id_sep = CompositePrimayKeys::ActiveRecord::Base::ID_SEP)
+          ids.map{|id| self.class.sanitize(id)}.join("#{id_sep}")
+        end
+  
+        # Enables Active Record objects to be used as URL parameters in Action Pack automatically.
+        def to_param
+          id_to_s(ids)
+        end
+  
+        def id_before_type_cast #:nodoc:
+          # TODO
+          read_attribute_before_type_cast(self.class.primary_key)
+        end
+  
+        def quoted_id #:nodoc:
+          # TODO
+          quote(id, column_for_attribute(self.class.primary_key))
+        end
+  
+        # Sets the primary ID.
+        def id=(value)
+          ids = id.split(value) if value.is_a?(String)
+          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
+          ids.each {|id| write_attribute(self.class.primary_key , id)}
+        end
+        
+        # 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
+          access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
+          
+          unless self.class.primary_keys.include? attr_name.to_sym
+            access_code = access_code.insert(0, "raise NoMethodError, 'missing attribute: #{attr_name}', caller unless @attributes.has_key?('#{attr_name}'); ")
+            self.class.read_methods << attr_name
+          end
+          
+          evaluate_read_method attr_name, "def #{symbol}; #{access_code}; end"
+        end
+        
+        def method_missing(method_id, *args, &block)
+          method_name = method_id.to_s
+          if @attributes.include?(method_name) or
+              (md = /\?$/.match(method_name) and
+              @attributes.include?(method_name = md.pre_match))
+            define_read_methods if self.class.read_methods.empty? && self.class.generate_read_methods
+            md ? query_attribute(method_name) : read_attribute(method_name)
+          elsif self.class.primary_keys.include? method_name.to_sym
+            get_attr(method_name.to_sym)
+          elsif md = /(=|_before_type_cast)$/.match(method_name)
+            attribute_name, method_type = md.pre_match, md.to_s
+            if @attributes.include?(attribute_name)
+              case method_type
+                when '='
+                  write_attribute(attribute_name, args.first)
+                when '_before_type_cast'
+                  read_attribute_before_type_cast(attribute_name)
+              end
+            else
+              super
+            end
+          else
+            super
+          end
+        end
+      end
+      
+      module CompositeClassMethods
+        
+        def primary_keys_to_s(sep = CompositePrimayKeys::ActiveRecord::Base::ID_SEP)
+          primary_keys.map(&:to_s).join(sep)
+        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(ids, id_sep = CompositePrimayKeys::ActiveRecord::Base::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
+          "#{left_bracket}#{ids.map{|id| sanitize(id)}.join('#{id_sep}')}#{right_bracket}"
+        end
+  
+        # Returns true if the given +ids+ represents the primary keys of a record in the database, false otherwise.
+        # Example:
+        #   Person.exists?(5,7)
+        def exists?(ids)
+          obj = find(ids) rescue false
+          !obj.nil? and obj.is_a?(self)
+        end
+  
+        # Deletes the record with the given +ids+ without instantiating an object first, e.g. delete(1,2)
+        # If an array of ids is provided (e.g. delete([1,2], [3,4]), all of them
+        # are deleted.
+        def delete(*ids)
+          delete_all([ "(#{primary_keys_to_s}) IN (#{ids_to_s(ids)})" ])
+        end
+  
+        # Destroys the record with the given +ids+ by instantiating the object and calling #destroy (all the callbacks are the triggered).
+        # If an array of ids is provided, all of them are destroyed.
+        def destroy(*ids)
+          ids.first.is_a?(Array) ? ids.each { |id_set| destroy(id_set) } : find(ids).destroy
+        end
+       
+        # Alias for the composite primary_keys accessor method
+        def primary_key
+          raise CompositePrimayKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
+          # primary_keys
+          # Initially invalidate the method to find places where its used
+        end
+  
+        # Returns an array of column objects for the table associated with this class.
+        # Each column that matches to one of the primary keys has its
+        # primary attribute set to true
+        def columns
+          unless @columns
+            @columns = connection.columns(table_name, "#{name} Columns")
+            @columns.each {|column| column.primary = primary_keys.include?(column.name.to_sym)}
+          end
+          @columns
+        end
+          
+        ## DEACTIVATED METHODS ##
+        public
+        # Lazy-set the sequence name to the connection's default.  This method
+        # is only ever called once since set_sequence_name overrides it.
+          def sequence_name #:nodoc:
+            raise CompositePrimayKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
+          end
+    
+          def reset_sequence_name #:nodoc:
+            raise CompositePrimayKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
+          end
+    
+          def set_primary_key(value = nil, &block)
+            raise CompositePrimayKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
+          end
+       
+        private
+          def find_one(id, options)
+            raise CompositePrimayKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
+          end
+       
+          def find_some(ids, options)
+            raise CompositePrimayKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
+          end
+  
+          def find_from_ids(ids, options)
+            conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
+            # if ids is just a flat list, then its size must = primary_key.length (one id per primary key, in order)
+            # if ids is list of lists, then each inner list must follow rule above
+            #if ids.first.is_a?(String) - find '2,1' -> find_from_ids ['2,1']
+            ids = ids[0].split(';').map {|id_set| id_set.split ','} if ids.first.is_a? String
+            ids = [ids] if not ids.first.kind_of?(Array)
+            
+            ids.each do |id_set| 
+              unless id_set.is_a?(Array)
+                raise "Ids must be in an Array, instead received: #{id_set.inspect}"
+              end
+              unless id_set.length == primary_keys.length
+                raise "Incorrect number of primary keys for #{class_name}: #{primary_keys.inspect}"
+              end
+            end
+            
+            # Let keys = [:a, :b]
+            # If ids = [[10, 50], [11, 51]], then :conditions => 
+            #   "(#{table_name}.a, #{table_name}.b) IN ((10, 50), (11, 51))"
+            
+            keys_sql = primary_keys.map {|key| "#{table_name}.#{key.to_s}"}.join(',')
+            ids_sql  = ids.map {|id_set| id_set.map {|id| sanitize(id)}.join(',')}.join('),(')
+            options.update :conditions => "(#{keys_sql}) IN ((#{ids_sql}))"
+  
+            result = find_every(options)
+  
+            if result.size == ids.size
+              ids.size == 1 ? result[0] : result
+            else
+              raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
+            end
+          end
+
+      end
+    end
+  end
+end