schema_associations 0.1.0.pre1

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+.*.sw?
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+.rvmrc
+*.log
+*.sqlite3
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2006 RedHill Consulting, Pty. Ltd.
+Copyright (c) 2009 Michal Lomnicki & Ronen Barzel 
+
+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.
+
+Except as contained in this notice, the name(s) of the above copyright
+holders shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in this Software without prior written authorization.
+
+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.rdoc

@@ -0,0 +1,89 @@
+= SchemaAssociations
+
+== Overview
+
+One of the great things about Rails (ActiveRecord, in particular) is that it
+inspects the database and automatically defines accessors for all your
+columns, keeping your model class definitions simple and DRY.  That's great
+for simple data columns, but where it falls down is when your table
+contains references to other tables: then the "accessors" you need are the
++belongs_to+, +has_one+, +has_many+, and +has_and_belongs_to_many+
+associations -- and you need to put them into your model class definitions by hand, which isn't so DRY.
+
+Enter the SchemaAssociations gem.  It extends ActiveRecord to automatically
+define the appropriate associations based on foreign key constraints in the
+database.  SchemaAssociations builds on the
+{+schema_plus+}[http://rubygems.org/gems/schema_plus] gem that
+automatically defines foreign key constraints.  So the common case is simple -- if you have this in your migration:
+
+    create_table :posts do |t|
+    end
+
+    create_table :comments do |t|
+      t.integer post_id
+      # ... whatever ...
+    end
+
+Then SchemaAssociations will define the corresponding associations:
+
+    Post.has_many :comments
+    Comment.belongs_to :post
+
+
+== What if I want something special?
+
+You're always free to define associations yourself, if for example you want
+to pass special options.  SchemaAssociations won't clobber any existing
+definitions.
+
+You can also control the behavior with various options, globally via
+SchemaAssociations.setup or per-model via #schema_associations.  See
+SchemaAssociations::Config for the available options.
+
+== Full details
+
+=== The basics
+
+=== Multiple references
+
+=== Concise names
+
+=== How do I know what it did?
+
+== Compatibility
+
+SchemaAssociations supports all combinations of:
+* rails 3.0 or 3.1
+* MRI ruby 1.8.7 or 1.9.2
+
+== Installation
+
+Install from http://rubygems.org via
+
+        $ gem install "schema_associations"
+
+or in a Gemfile
+
+        gem "schema_associations"
+
+== History
+
+* SchemaAssociations is derived from the "Red Hill On Rails" plugin
+ foreign_key_associations originally created by harukizaemon
+  (https://github.com/harukizaemon)
+
+* SchemaAssociations was created in 2011 by Michal Lomnicki and Ronen Barzel
+
+== Testing
+
+SchemaAssociations is tested using rspec and sqlite3.  To run the tests, after you've forked & cloned: 
+
+  $ cd schema_associations
+  $ bundle install
+  $ rake spec
+
+If you're running ruby 1.9.2, code coverage results will be in coverage/index.html -- it should be at 100% coverage.
+
+== License
+
+This plugin is released under the MIT license.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = '-Ispec'
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "schema_associations #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :postgresql do
+  desc 'Build the PostgreSQL test databases'
+  task :build_databases do
+    %x( createdb -E UTF8 schema_associations_unittest )
+  end
+
+  desc 'Drop the PostgreSQL test databases'
+  task :drop_databases do
+    %x( dropdb schema_associations_unittest )
+  end
+
+  desc 'Rebuild the PostgreSQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+end
+
+task :build_postgresql_databases => 'postgresql:build_databases'
+task :drop_postgresql_databases => 'postgresql:drop_databases'
+task :rebuild_postgresql_databases => 'postgresql:rebuild_databases'
+
+MYSQL_DB_USER = 'schema_assoc'
+namespace :mysql do
+  desc 'Build the MySQL test databases'
+  task :build_databases do
+    %x( echo "create DATABASE schema_associations_unittest DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci " | mysql --user=#{MYSQL_DB_USER})
+  end
+
+  desc 'Drop the MySQL test databases' 
+  task :drop_databases do
+    %x( mysqladmin --user=#{MYSQL_DB_USER} -f drop schema_associations_unittest )
+  end
+
+  desc 'Rebuild the MySQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+end
+
+task :build_mysql_databases => 'mysql:build_databases'
+task :drop_mysql_databases => 'mysql:drop_databases'
+task :rebuild_mysql_databases => 'mysql:rebuild_databases'

data/init.rb

@@ -0,0 +1 @@
+require 'schema_associations' unless defined?(SchemaAssociations)

data/lib/schema_associations/active_record/associations.rb

@@ -0,0 +1,223 @@
+require 'ostruct'
+
+module SchemaAssociations
+  module ActiveRecord
+    module Associations #:nodoc:
+
+      module Relation #:nodoc:
+        def self.included(base)
+          base.alias_method_chain :initialize, :schema_associations
+        end
+
+        def initialize_with_schema_associations(klass, *args)
+          klass.send :_load_schema_associations_associations
+          initialize_without_schema_associations(klass, *args)
+        end
+      end
+
+      def self.extended(base) #:nodoc:
+        class << base
+          alias_method_chain :reflect_on_association, :schema_associations
+          alias_method_chain :reflect_on_all_associations, :schema_associations
+        end
+        ::ActiveRecord::Relation.send :include, Relation
+      end
+
+      def reflect_on_association_with_schema_associations(*args) #:nodoc:
+        _load_schema_associations_associations
+        reflect_on_association_without_schema_associations(*args)
+      end
+
+      def reflect_on_all_associations_with_schema_associations(*args) #:nodoc:
+        _load_schema_associations_associations
+        reflect_on_all_associations_without_schema_associations(*args)
+      end
+
+      def define_attribute_methods(*args) #:nodoc:
+        super
+        _load_schema_associations_associations
+      end
+
+      # Per-model override of Config options.  Use via, e.g.
+      #     class MyModel < ActiveRecord::Base
+      #         schema_associations :auto_create => false
+      #     end
+      def schema_associations(opts)
+        @schema_associations_config = SchemaAssociations.config.merge(opts)
+      end
+
+      def schema_associations_config # :nodoc:
+        @schema_associations_config ||= SchemaAssociations.config.dup
+      end
+
+      private
+
+      def _load_schema_associations_associations #:nodoc:
+        return if @schema_associations_associations_loaded
+        @schema_associations_associations_loaded = true
+        return unless schema_associations_config.auto_create?
+
+        reverse_foreign_keys.each do | foreign_key |
+          if foreign_key.table_name =~ /^#{table_name}_(.*)$/ || foreign_key.table_name =~ /^(.*)_#{table_name}$/
+            other_table = $1
+            if other_table == other_table.pluralize and connection.columns(foreign_key.table_name).any?{|col| col.name == "#{other_table.singularize}_id"}
+              _define_association(:has_and_belongs_to_many, foreign_key, other_table)
+            else
+              _define_association(:has_one_or_many, foreign_key)
+            end
+          else
+            _define_association(:has_one_or_many, foreign_key)
+          end
+        end
+
+        foreign_keys.each do | foreign_key |
+          _define_association(:belongs_to, foreign_key)
+        end
+      end
+
+      def _define_association(macro, fk, referencing_table_name = nil) #:nodoc:
+        return unless fk.column_names.size == 1
+
+        referencing_table_name ||= fk.table_name
+
+        column_name = fk.column_names.first
+        reference_name = column_name.sub(/_id$/, '')
+        references_name = fk.references_table_name.singularize
+        referencing_name = referencing_table_name.singularize
+
+        references_class_name = references_name.classify
+        referencing_class_name = referencing_name.classify
+
+        references_concise = _concise_name(references_name, referencing_name)
+        referencing_concise = _concise_name(referencing_name, references_name)
+
+        case reference_name
+        when 'parent'
+          belongs_to         = 'parent'
+          belongs_to_concise = 'parent'
+
+          has_one            = 'child'
+          has_one_concise    = 'child'
+
+          has_many           = 'children'
+          has_many_concise   = 'children'
+
+        when references_name
+          belongs_to         = references_name
+          belongs_to_concise = references_concise
+
+          has_one            = referencing_name
+          has_one_concise    = referencing_concise
+
+          has_many           = referencing_name.pluralize
+          has_many_concise   = referencing_concise.pluralize
+
+        when /(.*)_#{references_name}$/, /(.*)_#{references_concise}$/
+          label = $1
+          belongs_to         = "#{label}_#{references_name}"
+          belongs_to_concise = "#{label}_#{references_concise}"
+
+          has_one            = "#{referencing_name}_as_#{label}"
+          has_one_concise    = "#{referencing_concise}_as_#{label}"
+
+          has_many           = "#{referencing_name.pluralize}_as_#{label}"
+          has_many_concise   = "#{referencing_concise.pluralize}_as_#{label}"
+
+        when /^#{references_name}_(.*)$/, /^#{references_concise}_(.*)$/
+          label = $1
+          belongs_to            = "#{references_name}_#{label}"
+          belongs_to_concise    = "#{references_concise}_#{label}"
+
+          has_one               = "#{referencing_name}_as_#{label}"
+          has_one_concise       = "#{referencing_concise}_as_#{label}"
+
+          has_many              = "#{referencing_name.pluralize}_as_#{label}"
+          has_many_concise      = "#{referencing_concise.pluralize}_as_#{label}"
+
+        else
+          belongs_to            = reference_name
+          belongs_to_concise    = reference_name
+
+          has_one               = "#{referencing_name}_as_#{reference_name}"
+          has_one_concise       = "#{referencing_concise}_as_#{reference_name}"
+
+          has_many              = "#{referencing_name.pluralize}_as_#{reference_name}"
+          has_many_concise      = "#{referencing_concise.pluralize}_as_#{reference_name}"
+        end
+
+        case macro
+        when :has_and_belongs_to_many
+          name = has_many
+          name_concise = has_many_concise
+          opts = {:class_name => referencing_class_name, :join_table => fk.table_name, :foreign_key => column_name}
+        when :belongs_to
+          name = belongs_to
+          name_concise = belongs_to_concise
+          opts = {:class_name => references_class_name, :foreign_key => column_name}
+        when :has_one_or_many
+          opts = {:class_name => referencing_class_name, :foreign_key => column_name}
+          # use connection.indexes and connection.colums rather than class
+          # methods of the referencing class because using the class
+          # methods would require getting the class -- which might trigger
+          # an autoload which could start some recursion making things much
+          # harder to debug.
+          if connection.indexes(referencing_table_name, "#{referencing_table_name} Indexes").any?{|index| index.unique && index.columns == [column_name]}
+            macro = :has_one
+            name = has_one
+            name_concise = has_one_concise
+          else
+            macro = :has_many
+            name = has_many
+            name_concise = has_many_concise
+            if connection.columns(referencing_table_name, "#{referencing_table_name} Columns").any?{ |col| col.name == 'position' }
+              opts[:order] = :position
+            end
+          end
+        end
+        name = name_concise if _use_concise_name?
+        name = name.to_sym
+        if (_filter_association(macro, name) && !_method_exists?(name))
+          logger.info "[schema_associations] #{self.name || self.table_name.classify}.#{macro} #{name.inspect}, #{opts.inspect[1...-1]}"
+          send macro, name, opts.dup
+        end
+      end
+
+      def _concise_name(string, other) #:nodoc:
+        case
+        when string =~ /^#{other}_(.*)$/           then $1
+        when string =~ /(.*)_#{other}$/            then $1
+        when leader = _common_leader(string,other) then string[leader.length, string.length-leader.length]
+        else                                            string
+        end
+      end
+
+      def _common_leader(string, other) #:nodoc:
+        leader = nil
+        other.split('_').each do |part|
+          test = "#{leader}#{part}_"
+          break unless string.start_with? test
+          leader = test
+        end
+        return leader
+      end
+
+      def _use_concise_name? #:nodoc:
+        schema_associations_config.concise_names?
+      end
+
+      def _filter_association(macro, name) #:nodoc:
+        config = schema_associations_config
+        return false if config.only        and not Array.wrap(config.only).include?(name)
+        return false if config.except      and     Array.wrap(config.except).include?(name)
+        return false if config.only_type   and not Array.wrap(config.only_type).include?(macro)
+        return false if config.except_type and     Array.wrap(config.except_type).include?(macro)
+        return true
+      end
+
+      def _method_exists?(name) #:nodoc:
+        method_defined?(name) || private_method_defined?(name) and not (name == :type && [Object, Kernel].include?(instance_method(:type).owner))
+      end
+
+    end
+  end
+end

data/lib/schema_associations/railtie.rb

@@ -0,0 +1,9 @@
+module SchemaAssociations 
+  class Railtie < Rails::Railtie #:nodoc:
+
+    initializer 'schema_associations.insert', :after => :load_config_initializers do
+      SchemaAssociations.insert
+    end
+
+  end
+end

data/lib/schema_associations/version.rb

@@ -0,0 +1,3 @@
+module SchemaAssociations
+  VERSION = "0.1.0.pre1"
+end

data/lib/schema_associations.rb

@@ -0,0 +1,112 @@
+require 'schema_plus'
+require 'valuable'
+
+require 'schema_associations/version'
+require 'schema_associations/active_record/associations'
+require 'schema_associations/railtie' if defined?(Rails)
+
+module SchemaAssociations
+
+  # The configuation options for SchemaAssociations. Set them globally in
+  # +config/initializers/schema_associations.rb+, e.g.:
+  #
+  #    SchemaAssociations.setup do |config|
+  #       config.concise_names = false
+  #    end
+  #
+  # or override them per-model, e.g.:
+  #
+  #     class MyModel < ActiveRecord::Base
+  #        schema_associations.config :concise_names => false
+  #     end
+  #
+  class Config < Valuable
+
+    ##
+    # :attr_accessor: auto_create
+    #
+    # Whether to automatically create associations based on foreign keys.
+    # Boolean, default is +true+.
+    has_value :auto_create, :klass => :boolean, :default => true
+
+    ##
+    # :attr_accessor: concise_names
+    #
+    # Whether to use concise naming (strip out common prefixes from class names).
+    # Boolean, default is +true+.
+    has_value :concise_names, :klass => :boolean, :default => true
+
+    ##
+    # :attr_accessor: except
+    #
+    # List of association names to exclude from automatic creation.
+    # Value is a single name, an array of names, or +nil+.  Default is +nil+.
+    has_value :except, :default => nil
+
+    ##
+    # :attr_accessor: only
+    #
+    # List of association names to include in automatic creation.
+    # Value is a single name, and array of names, or +nil+.  Default is +nil+.
+    has_value :only, :default => nil
+
+    ##
+    # :attr_accessor: except_type
+    #
+    # List of association types to exclude from automatic creation.
+    # Value is one or an array of +:belongs_to+, +:has_many+, +:has_one+, and/or
+    # +:has_and_belongs_to_many+, or +nil+.  Default is +nil+.
+    has_value :except_type, :default => nil
+
+    ##
+    # :attr_accessor: only_type
+    #
+    # List of association types to include from automatic creation.
+    # Value is one or an array of +:belongs_to+, +:has_many+, +:has_one+, and/or
+    # +:has_and_belongs_to_many+, or +nil+.  Default is +nil+.
+    has_value :only_type, :default => nil
+
+    def dup #:nodoc:
+      self.class.new(Hash[attributes.collect{ |key, val| [key, Valuable === val ?  val.class.new(val.attributes) : val] }])
+    end
+
+    def update_attributes(opts)#:nodoc:
+      opts = opts.dup
+      opts.keys.each { |key| self.send(key).update_attributes(opts.delete(key)) if self.class.attributes.include? key and Hash === opts[key] }
+      super(opts)
+      self
+    end
+
+    def merge(opts)#:nodoc:
+      dup.update_attributes(opts)
+    end
+
+  end
+
+  # Returns the global configuration, i.e., the singleton instance of Config
+  def self.config
+    @config ||= Config.new
+  end
+
+  # Initialization block is passed a global Config instance that can be
+  # used to configure SchemaAssociations behavior.  E.g., if you want to
+  # disable automation creation associations put the following in
+  # config/initializers/schema_associations.rb :
+  #
+  #    SchemaAssociations.setup do |config|
+  #       config.auto_create = false
+  #    end
+  #
+  def self.setup # :yields: config
+    yield config
+  end
+
+  def self.insert #:nodoc:
+    return if @inserted
+    @inserted = true
+    ::ActiveRecord::Base.extend SchemaAssociations::ActiveRecord::Associations
+  end
+
+end
+
+SchemaAssociations.insert unless defined? Rails::Railtie

data/schema_associations.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "schema_associations/version"
+
+Gem::Specification.new do |s|
+  s.name        = "schema_associations"
+  s.version     = SchemaAssociations::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
+  s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
+  s.homepage    = "https://github.com/ronen/schema_associations"
+  s.summary     = "ActiveRecord extension that automatically (DRY) creates associations based on the schema"
+  s.description = "SchemaAssociations extends ActiveRecord to automatically create associations by inspecting the database schema.  This is more more DRY than the standard behavior, for which in addition to specifying the foreign key in the migration, you must also specify complementary associations in two model files (e.g. a :belongs_to and a :has_many)."
+
+  s.rubyforge_project = "schema_associations"
+
+  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"]
+
+  s.add_dependency("schema_plus")
+      
+  s.add_development_dependency("rake", "~> 0.8.7")
+  s.add_development_dependency("rails", ">= 3.1.0.rc1")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("simplecov")
+  s.add_development_dependency("simplecov-gem-adapter")
+  s.add_development_dependency("ruby-debug19") if RUBY_VERSION >= "1.9.2"
+end
+

data/schema_associations.gemspec.rails3.0

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "schema_associations/version"
+
+Gem::Specification.new do |s|
+  s.name        = "schema_associations"
+  s.version     = SchemaAssociations::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
+  s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
+  s.homepage    = "https://github.com/ronen/schema_associations"
+  s.summary     = "ActiveRecord extension that automatically (DRY) creates associations based on the schema"
+  s.description = "SchemaAssociations extends ActiveRecord to automatically create associations by inspecting the database schema.  This is more more DRY than the standard behavior, for which in addition to specifying the foreign key in the migration, you must also specify complementary associations in two model files (e.g. a :belongs_to and a :has_many)."
+
+  s.rubyforge_project = "schema_associations"
+
+  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"]
+
+  s.add_dependency("schema_plus")
+  s.add_dependency("valuable")
+      
+  s.add_development_dependency("rails", "~> 3.0")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("pg")
+  s.add_development_dependency("mysql")
+  s.add_development_dependency("mysql2", "0.2.6")
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("simplecov")
+  s.add_development_dependency("simplecov-gem-adapter")
+  s.add_development_dependency("ruby-debug19") if RUBY_VERSION >= "1.9.2"
+end
+

data/schema_associations.gemspec.rails3.1

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "schema_associations/version"
+
+Gem::Specification.new do |s|
+  s.name        = "schema_associations"
+  s.version     = SchemaAssociations::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
+  s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
+  s.homepage    = "https://github.com/ronen/schema_associations"
+  s.summary     = "ActiveRecord extension that automatically (DRY) creates associations based on the schema"
+  s.description = "SchemaAssociations extends ActiveRecord to automatically create associations by inspecting the database schema.  This is more more DRY than the standard behavior, for which in addition to specifying the foreign key in the migration, you must also specify complementary associations in two model files (e.g. a :belongs_to and a :has_many)."
+
+  s.rubyforge_project = "schema_associations"
+
+  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"]
+
+  s.add_dependency("schema_plus")
+  s.add_dependency("valuable")
+      
+  s.add_development_dependency("rake", "~> 0.8.7")
+  s.add_development_dependency("rails", ">= 3.1.0.rc1")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("pg")
+  s.add_development_dependency("mysql")
+  s.add_development_dependency("mysql2")
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("simplecov")
+  s.add_development_dependency("simplecov-gem-adapter")
+  s.add_development_dependency("ruby-debug19") if RUBY_VERSION >= "1.9.2"
+end
+