authorails 1.0.0

data/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/schema_statements.rb

@@ -0,0 +1,23 @@
+module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
+  module SchemaStatements
+    def self.included(base)
+      base.module_eval do
+        alias_method_chain :create_table, :redhillonrails_core
+      end
+    end
+
+    def create_table_with_redhillonrails_core(name, options = {})
+      if options.include?(:comment)
+        options = options.dup
+        comment = options.delete(:comment)
+      end
+
+      create_table_without_redhillonrails_core(name, options) do |table_defintion|
+        table_defintion.name = name
+        yield table_defintion if block_given?
+      end
+
+      set_table_comment(name, comment) if comment
+    end
+  end
+end

data/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,9 @@
+module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
+  module Sqlite3Adapter
+    def add_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {})
+    end
+
+    def remove_foreign_key(table_name, foreign_key_name)
+    end
+  end
+end

data/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/connection_adapters/table_definition.rb

@@ -0,0 +1,27 @@
+module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
+  module TableDefinition
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :name
+        alias_method_chain :initialize, :redhillonrails_core
+        alias_method_chain :to_sql, :redhillonrails_core
+      end
+    end
+
+    def initialize_with_redhillonrails_core(*args)
+      initialize_without_redhillonrails_core(*args)
+      @foreign_keys = []
+    end
+
+    def foreign_key(column_names, references_table_name, references_column_names, options = {})
+      @foreign_keys << ForeignKeyDefinition.new(options[:name], nil, column_names, ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
+      self
+    end
+
+    def to_sql_with_redhillonrails_core
+      sql = to_sql_without_redhillonrails_core
+      sql << ', ' << @foreign_keys * ', ' unless @foreign_keys.empty? || ActiveRecord::Schema.defining?
+      sql
+    end
+  end
+end

data/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/schema.rb

@@ -0,0 +1,25 @@
+module RedHillConsulting::Core::ActiveRecord
+  module Schema
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        class << base
+          attr_accessor :defining
+          alias :defining? :defining
+
+          alias_method_chain :define, :redhillonrails_core
+        end
+      end
+
+      def define_with_redhillonrails_core(info={}, &block)
+        self.defining = true
+        define_without_redhillonrails_core(info, &block)
+      ensure
+        self.defining = false
+      end
+    end
+  end
+end

data/plugins/redhillonrails_core/lib/red_hill_consulting/core/active_record/schema_dumper.rb

@@ -0,0 +1,58 @@
+module RedHillConsulting::Core::ActiveRecord
+  module SchemaDumper
+    def self.included(base)
+      base.class_eval do
+        private
+        alias_method_chain :tables, :redhillonrails_core
+        alias_method_chain :indexes, :redhillonrails_core
+      end
+    end
+
+    private
+
+    def tables_with_redhillonrails_core(stream)
+      @foreign_keys = StringIO.new
+      begin
+        tables_without_redhillonrails_core(stream)
+        @foreign_keys.rewind
+        stream.print @foreign_keys.read
+        views(stream)
+      ensure
+        @foreign_keys = nil
+      end
+    end
+
+    def indexes_with_redhillonrails_core(table, stream)
+      indexes = @connection.indexes(table)
+      indexes.each do |index|
+        stream.print "  add_index #{index.table.inspect}, #{index.columns.inspect}, :name => #{index.name.inspect}"
+        stream.print ", :unique => true" if index.unique
+        stream.print ", :case_sensitive => false" unless index.case_sensitive?
+        stream.puts
+      end
+      stream.puts unless indexes.empty?
+
+      foreign_keys(table, @foreign_keys)
+    end
+
+    def foreign_keys(table, stream)
+      foreign_keys = @connection.foreign_keys(table)
+      foreign_keys.each do |foreign_key|
+        stream.print "  "
+        stream.print foreign_key.to_dump
+        stream.puts
+      end
+      stream.puts unless foreign_keys.empty?
+    end
+    
+    def views(stream)
+      views = @connection.views
+      views.each do |view_name|
+        definition = @connection.view_definition(view_name)
+        stream.print "  create_view #{view_name.inspect}, #{definition.inspect}"
+        stream.puts
+      end
+      stream.puts unless views.empty?
+    end
+  end
+end

data/plugins/redhillonrails_core/lib/redhillonrails_core.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Base.send(:include, RedHillConsulting::Core::ActiveRecord::Base)
+ActiveRecord::Schema.send(:include, RedHillConsulting::Core::ActiveRecord::Schema)
+ActiveRecord::SchemaDumper.send(:include, RedHillConsulting::Core::ActiveRecord::SchemaDumper)
+ActiveRecord::ConnectionAdapters::IndexDefinition.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::IndexDefinition)
+ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::TableDefinition)
+ActiveRecord::ConnectionAdapters::Column.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::Column)
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::AbstractAdapter)
+ActiveRecord::ConnectionAdapters::SchemaStatements.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::SchemaStatements)
+
+if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) then
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::PostgresqlAdapter)
+end
+if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) then
+  ActiveRecord::ConnectionAdapters::MysqlColumn.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::MysqlColumn)
+  ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::MysqlAdapter)
+end
+if defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter) then
+  ActiveRecord::ConnectionAdapters::SQLite3Adapter.send(:include, RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::Sqlite3Adapter)
+end

data/plugins/redhillonrails_core/tasks/db/comments.rake

@@ -0,0 +1,9 @@
+namespace :db do
+  desc "Describe all the tables in the database by reading the table comments"
+  task :comments => :environment do
+    ActiveRecord::Base.connection.tables.sort.each do |table_name|
+      comment = ActiveRecord::Base.connection.table_comment(table_name)
+      puts "#{table_name} - #{comment}"
+    end
+  end
+end

data/plugins/schema_validations/CHANGELOG

@@ -0,0 +1,149 @@
+[REVISION 20080131]
+
+[FIXED] belongs_to associations failing when no table exists.
+
+[REVISION 20071128]
+
+[FIXED] Workaround to ensure plugin is only ever loaded once.
+
+[REVISION 20070321]
+
+[FIXED] Sub-class meta-data missing if loaded before super-class.
+
+[REVISION 20070302]
+
+[NEW] Validation may be limited to specific columns by calling schema_validations from within your model class, passing either a single column (:only => :name) or an array of columns (:except => [:isocode, :iddcode]).
+
+[CHANGED] Use symbols rather than strings when calling validation methods as this seems to be the "way of the future" :).
+
+[REVISION 20070224]
+
+[FIXED] Removed useless assignment of class variable.
+
+[REVISION 20070221]
+
+[NEW] Where possible, validates_uniqueness_of adds the :case_sensitivity option based on the presence of case-insensitive indexes.
+
+[REVISION 20061203]
+
+[CHANGED] Lazily load meta-data during allocate/new rather than inherited.
+
+[FIXED] Explicit table name ignored.
+
+[REVISION 20061202]
+
+[CHANGED] Use Rails 1.2 alias_method_chain.
+
+[CHANGED] Separate modules into individual files.
+
+[REVISION 20061114]
+
+[FIXED] NOT NULL columns with a default not marked as required for update.
+
+[REVISION 20061013]
+
+[NEW] install.rb informs user of missing dependencies.
+
+[REVISION 20061012]
+
+[CHANGED] Only read meta-data for base-classes.
+
+[REVISION 20061011]
+
+[CHANGED] Use include rather than extend in init.rb as this is more general. Plugin code can then determine if it needs to use extend or not.
+
+[REVISION 20061020]
+
+[FIXED] Breaks abstract class inheritance. If classes are named 'AbstractXxx' they will be treated as abstract. This is somewhat of a work-around for the current implementation however I believe it is a sensible choice for now.
+
+[REVISION 20060924]
+
+[FIXED] validates_uniqueness_of causes new records to fail when nullable column is null and there exists another record where the value of the column is also null. NULL values should always be considered unique.
+
+[REVISION 20060915]
+
+[NEW] Multi-column unique indexes are converted to validates_uniqueness_of with scope. The column validated for uniqueness is either the last column not ending in '_id' or simply the last column. This follows the typical composite unique index column ordering where the scoping is specified first but will attempt to find the last non-foreign-key column just-in-case. Eg, both add_index :states, [:country_id, :name], :unique => true and add_index :states, [:name, :country_id], :unique => true would result in <code>validates_uniqueness_of :name, :scope => [:country_id].
+
+[REVISION 20060914]
+
+[CHANGED] Removed unnecessary condition from validates_presence_of for associations.
+
+[REVISION 20060913]
+
+[FIXED] validates_presence_of for associations causes new records to fail.
+
+[REVISION 20060912]
+
+[FIXED] 'Before updating scaffolding from new DB schema, try creating a table for your model (<model>)' when running ./script/generate scaffold <model>. Seems the scaffold sandbox dynamically creates classes which have no name.
+
+[REVISION 20060911]
+
+[CHANGED] Revert to nil defaults--as opposed to blank--now that the MySQL behaviour has been patched in redhillonrails_core.
+
+[REVISION 20060909]
+
+[NEW] Dependency on RedHill on Rails Core.
+
+[NEW] validates_uniqueness_of for associations.
+
+[FIXED] validates_presence_of for associations.
+
+[REVISION 20060908]
+
+[FIXED] validates_presence_of not being applied under MySQL; empty defaults are represented as blank rather than nil.
+
+[NEW] validates_uniqueness_of for associations.
+
+[REVISION 20060818]
+
+[FIXED] 'Before updating scaffolding from new DB schema, try creating a table for your model (<model>)' when running ./script/generate scaffold <model>.
+
+[FIXED] 'relation "system_settings" does not exist' when running a migrate with system_settings plugin installed.
+
+[REVISION 20060816]
+
+[FIXED] Overly greedy regex ignoring all date/time columns.
+
+[REVISION 20060812]
+
+[CHANGED] Documentation updated to reflect the fact that no further action is required once the plugin is installed.
+
+[REVISION 20060812]
+
+[FIXED] Documentation mentions :integer => true options; this should have read :only_integer => true.
+
+[REVISION 20060803]
+
+[FIXED] Revision 50 comments out the validates_presence_of magic on line 13 in belongs_to_with_schema_validations.
+
+[REVISION 20060802]
+
+[NEW] Support for validates_uniqueness_of for single-column unique indexes.
+
+[CHANGED] Error message for boolean fields to be the same as the default for validates_presence_of
+
+[REVISION 20060723]
+
+[FIXED] Workaround for a "feature" of the way validates_presence_of handles boolean fields. See http://dev.rubyonrails.org/ticket/5090 and http://dev.rubyonrails.org/ticket/3334
+
+[REVISION 20060719]
+
+[NEW] Support validates_presence_of for belongs_to associations.
+
+[REVISION 20060718]
+
+[FIXED] String test checks #class instead of #klass
+
+[CHANGED] Separated out check for null from validation of numericality. This means you'll get a "xxx can't be blank" rather than an "xx isn't a number" which seems more intuitive to me.
+
+[FIXED] Default check should consider nil explicitly to allow for false.
+
+[REVISION 20060717]
+
+[NEW] Initial version.
+
+[FIXED] Ignore columns ending in: _id, _count, _at, _on.
+
+[NEW] Support validates_numericality_of for numbers (including :integer => true)
+
+[NEW] Support validates_length_of for strings

data/plugins/schema_validations/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 RedHill Consulting, Pty. Ltd.
+
+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/plugins/schema_validations/README

@@ -0,0 +1,54 @@
+= Schema Validations
+
+Schema Validations is a plugin that reads various constraints defined against
+columns in your database and applies the closest matching rails validation.
+(Ala Dave Thomas' Keynote.)
+
+Over and above installing the plugin, no further action is required for the
+validations to take effect; the database schema constraints will be read and
+applied as validations when your ActiveRecord model classes are loaded; just
+like magic.
+
+The plugin supports the following constraints:
+
+* <code>NOT NULL</code> is converted to +validates_presence_of+ (including +belongs_to+ associations);
+* Numbers are checked using +validates_numericality_of+ (including <code>:only_integer => true</code>);
+* String lengths are checked using +validates_length_of+;
+* Single-column unique indexes are converted to +validates_uniqueness_of+; and
+* Multi-column unique indexes are converted to +validates_uniqueness_of+ with +scope+.
+
+For multi-column unique indexes the column validated for uniqueness is either
+the last column not ending in '_id' or simply the last column. This follows the
+typical composite unique index column ordering where the scoping is specified
+first but will attempt to find the last non-foreign-key column just-in-case.
+
+For example, either of the following two statements in a schema migration script:
+
+  add_index :states, [:country_id, :name], :unique => true
+  add_index :states, [:name, :country_id], :unique => true
+
+would result in:
+
+  validates_uniqueness_of :name, :scope => [:country_id]
+
+Validation may be limited to specific columns by calling <code>schema_validations</code> from within
+your model class, passing either a single column:
+
+  class Country < ActiveRecord::Base
+    schema_validations :only => :name
+  end
+
+or an array of columns:
+
+  class Country < ActiveRecord::Base
+    schema_validations :except => [:isocode, :iddcode]
+  end
+
+=== Dependencies
+
+* RedHill on Rails Core (redhillonrails_core).
+
+=== License
+
+This plugin is copyright 2006 by RedHill Consulting, Pty. Ltd. and is released
+under the MIT license.

data/plugins/schema_validations/about.yml

@@ -0,0 +1,5 @@
+author: simon@redhillconsulting.com.au
+summary: Reads various constraints defined against columns in your database and applies the closest matching rails validation.
+homepage: http://www.redhillonrails.org
+license: MIT
+rails_version: EDGE

data/plugins/schema_validations/init.rb

@@ -0,0 +1 @@
+require 'schema_validations' unless defined?(RedHillConsulting::SchemaValidations)

data/plugins/schema_validations/install.rb

@@ -0,0 +1 @@
+puts "WARNING: You also need to install redhillonrails_core" unless File.exists?(File.join(File.dirname(__FILE__), "..", "redhillonrails_core"))

data/plugins/schema_validations/lib/red_hill_consulting/schema_validations/active_record/base.rb

@@ -0,0 +1,108 @@
+module RedHillConsulting::SchemaValidations::ActiveRecord
+  module Base
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        class << base
+          alias_method_chain :allocate, :schema_validations
+          alias_method_chain :new, :schema_validations
+        end
+      end
+
+      def inherited(child)
+        load_schema_validations unless self == ActiveRecord::Base
+        super
+      end
+
+      def schema_validations(options = {})
+        column_names = []
+        if options[:only]
+          column_names = options[:only]
+          @schema_validations_column_include = true
+        elsif options[:except]
+          column_names = options[:except]
+          @schema_validations_column_include = false
+        end
+
+        @schema_validations_column_names = Array(column_names).map(&:to_s)
+      end
+
+      def allocate_with_schema_validations
+        load_schema_validations
+        allocate_without_schema_validations
+      end
+
+      def new_with_schema_validations(*args)
+        load_schema_validations
+        new_without_schema_validations(*args) { |*block_args| yield(*block_args) if block_given? }
+      end
+
+      protected
+
+      def load_schema_validations
+        # Don't bother if: it's already been loaded; the class is abstract; not a base class; or the table doesn't exist
+        return if @schema_validations_loaded || abstract_class? || !base_class? || name.blank? || !table_exists?
+        @schema_validations_loaded = true
+        load_column_validations
+        load_association_validations
+      end
+
+      private
+      
+      def load_column_validations
+        content_columns.each do |column|
+          next unless validates?(column)
+
+          name = column.name.to_sym
+
+          # Data-type validation
+          if column.type == :integer
+            validates_numericality_of name, :allow_nil => true, :only_integer => true
+          elsif column.number?
+            validates_numericality_of name, :allow_nil => true
+          elsif column.text? && column.limit
+            validates_length_of name, :allow_nil => true, :maximum => column.limit
+          end
+
+          # NOT NULL constraints
+          if column.required_on
+            # Work-around for a "feature" of the way validates_presence_of handles boolean fields
+            # See http://dev.rubyonrails.org/ticket/5090 and http://dev.rubyonrails.org/ticket/3334
+            if column.type == :boolean
+              validates_inclusion_of name, :on => column.required_on, :in => [true, false], :message => ActiveRecord::Errors.default_error_messages[:blank]
+            else
+              validates_presence_of name, :on => column.required_on
+            end
+          end
+
+          # UNIQUE constraints
+          validates_uniqueness_of name, :scope => column.unique_scope.map(&:to_sym), :allow_nil => true, :case_sensitive => column.case_sensitive? if column.unique?
+        end
+      end
+      
+      def load_association_validations
+        columns = columns_hash
+        reflect_on_all_associations(:belongs_to).each do |association|
+          column = columns[association.primary_key_name]
+          next unless validates?(column)
+
+          # NOT NULL constraints
+          module_eval(
+            "validates_presence_of :#{column.name}, :on => :#{column.required_on}, :if => lambda { |record| record.#{association.name}.nil? }"
+          ) if column.required_on
+
+          # UNIQUE constraints
+          validates_uniqueness_of column.name.to_sym, :scope => column.unique_scope.map(&:to_sym), :allow_nil => true if column.unique?
+        end
+      end
+
+      def validates?(column)
+        column.name !~ /^(((created|updated)_(at|on))|position)$/ &&
+          (@schema_validations_column_names.nil? || @schema_validations_column_names.include?(column.name) == @schema_validations_column_include)
+      end
+    end
+  end
+end