schema_plus 1.8.9 → 2.0.0.pre1

data/lib/{schema_plus → schema_column_plus}/active_record/connection_adapters/column.rb

@@ -1,14 +1,13 @@
-module SchemaPlus
+module SchemaColumnPlus
   module ActiveRecord
     module ConnectionAdapters
 
       #
-      # SchemaPlus adds several methods to Column
+      # SchemaPlusIndex adds several methods to Column
       #
       module Column
 
-        attr_reader :default_expr
-        attr_writer :model # model gets set by SchemaPlus::ActiveRecord::Base::columns_with_schema_plus
+        attr_writer :model # model assigned set by Middleware::Model::Columns
 
         # Returns the list of IndexDefinition instances for each index that
         # refers to this column.  Returns an empty list if there are no
@@ -33,11 +32,19 @@ module SchemaPlus
         end
 
         # Returns true if the column is in one or more indexes that are
-        # case sensitive
+        # case sensitive.  Will raise exception if
+        # IndexDefinition#case_sensitive? isn't defined, i.e. if
+        # schema_plus_pg_indexes hasn't been loaded.
         def case_sensitive?
           indexes.any?{|i| i.case_sensitive?}
         end
 
+        # The default as_jon includes all instance variables.  but
+        # @model can't be dumped (it contains circular references)
+        def as_json(options=nil)
+          instance_values.except "model", "adapter"
+        end
+
         # Returns the circumstance in which the column must have a value:
         #   nil     if the column may be null
         #   :save   if the column has no default value
@@ -51,13 +58,8 @@ module SchemaPlus
             :update
           end
         end
-
-        # The default as_jon includes all instance variables.  but
-        # @model can't be dumped (it contains circular references)
-        def as_json(options=nil)
-          instance_values.except "model", "adapter"
-        end
       end
     end
   end
 end
+

data/lib/schema_column_plus/middleware/model.rb

@@ -0,0 +1,22 @@
+module SchemaColumnPlus
+  module Middleware
+    module Model
+
+      def self.insert
+        SchemaMonkey::Middleware::Model::Columns.append AddModels
+      end
+
+      class AddModels < SchemaMonkey::Middleware::Base
+        def call(env)
+          continue env
+
+          env.columns.each do |column|
+            column.model = env.model
+          end
+
+          env.columns
+        end
+      end
+    end
+  end
+end

data/lib/schema_db_default.rb

@@ -0,0 +1,13 @@
+require 'schema_monkey'
+
+require_relative 'schema_db_default/active_record/attribute'
+require_relative 'schema_db_default/db_default'
+require_relative 'schema_db_default/middleware'
+
+module SchemaDbDefault
+  def self.insert
+    ::ActiveRecord.const_set(:DB_DEFAULT, SchemaDbDefault::DB_DEFAULT)
+  end
+end
+
+SchemaMonkey.register(SchemaDbDefault)

data/lib/{schema_plus → schema_db_default}/active_record/attribute.rb

@@ -1,16 +1,16 @@
-module SchemaPlus
+module SchemaDbDefault
   module ActiveRecord
     module Attribute
       def self.included(base)
-        base.alias_method_chain :original_value, :schema_plus
+        base.alias_method_chain :original_value, :schema_db_default
       end
 
-      def original_value_with_schema_plus
+      def original_value_with_schema_db_default
         # prevent attempts to cast DB_DEFAULT to the attributes type.
         # We want to keep it as DB_DEFAULT so that we can handle it when
         # generating the sql.
         return DB_DEFAULT if value_before_type_cast.equal? DB_DEFAULT
-        original_value_without_schema_plus
+        original_value_without_schema_db_default
       end
 
     end

data/lib/schema_db_default/db_default.rb

@@ -0,0 +1,17 @@
+require 'singleton'
+
+module SchemaDbDefault
+  class DbDefault
+    include Singleton
+    def to_s
+      'DEFAULT'
+    end
+    def id
+      self
+    end
+    def quoted_id
+      self
+    end
+  end
+  DB_DEFAULT = DbDefault.instance
+end

data/lib/schema_db_default/middleware.rb

@@ -0,0 +1,30 @@
+module SchemaDbDefault
+  module Middleware
+    module PostgresqlAdapter
+      def self.insert
+        SchemaMonkey::Middleware::Query::ExecCache.prepend BindDbDefault
+      end
+    end
+
+    # Middleware to replace each ActiveRecord::DB_DEFAULT with a literal
+    # DEFAULT in the sql string, for postgresql.  The underlying pg gem provides no
+    # way to bind a value that will replace $n with DEFAULT.
+    class BindDbDefault < SchemaMonkey::Middleware::Base
+      def call(env)
+        if env.binds.any?{ |col, val| val.equal? ::ActiveRecord::DB_DEFAULT}
+          j = 0
+          env.binds.each_with_index do |(col, val), i|
+            if val.equal? ::ActiveRecord::DB_DEFAULT
+              env.sql = env.sql.sub(/\$#{i+1}/, 'DEFAULT')
+            else
+              env.sql = env.sql.sub(/\$#{i+1}/, "$#{j+1}") if i != j
+              j += 1
+            end
+          end
+          env.binds = env.binds.reject{|col, val| val.equal? ::ActiveRecord::DB_DEFAULT}
+        end
+        continue env
+      end
+    end
+  end
+end

data/lib/schema_default_expr.rb

@@ -0,0 +1,32 @@
+require 'schema_monkey'
+
+require_relative 'schema_default_expr/middleware'
+
+module SchemaDefaultExpr
+  module ActiveRecord
+    module ConnectionAdapters
+      #
+      # Each adapter needs to define these two functions:
+      #
+      # default_expr_valid?(expr)
+      #
+      # Return true if the passed expression can be used as a column
+      # default value.  (For most databases the specific expression
+      # doesn't matter, and the adapter's function would return a
+      # constant true if default expressions are supported or false if
+      # they're not.)
+      #
+      # sql_for_function(function_name)
+      #
+      # Return SQL definition for a given canonical function_name symbol.
+      # Currently, the only function to support is :now, which should
+      # return a DATETIME object for the current time.
+      #
+      autoload :MysqlAdapter, 'schema_default_expr/active_record/connection_adapters/mysql_adapter'
+      autoload :PostgresqlAdapter, 'schema_default_expr/active_record/connection_adapters/postgresql_adapter'
+      autoload :Sqlite3Adapter, 'schema_default_expr/active_record/connection_adapters/sqlite3_adapter'
+    end
+  end
+end
+
+SchemaMonkey.register(SchemaDefaultExpr)

data/lib/schema_default_expr/active_record/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,17 @@
+module SchemaDefaultExpr
+  module ActiveRecord
+    module ConnectionAdapters
+      module MysqlAdapter
+        def default_expr_valid?(expr)
+          false # only the TIMESTAMP column accepts SQL column defaults and rails uses DATETIME
+        end
+
+        def sql_for_function(function)
+          case function
+          when :now then 'CURRENT_TIMESTAMP'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_default_expr/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,18 @@
+module SchemaDefaultExpr
+  module ActiveRecord
+    module ConnectionAdapters
+      module PostgresqlAdapter
+        def default_expr_valid?(expr)
+          true # arbitrary sql is okay in PostgreSQL
+        end
+
+        def sql_for_function(function)
+          case function
+          when :now
+            "NOW()"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_default_expr/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,35 @@
+module SchemaDefaultExpr
+  module ActiveRecord
+    module ConnectionAdapters
+
+      module Sqlite3Adapter
+        def self.included(base)
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::Column, SQLiteColumn
+        end
+
+        def default_expr_valid?(expr)
+          true # arbitrary sql is okay
+        end
+
+        def sql_for_function(function)
+          case function
+          when :now
+            "(DATETIME('now'))"
+          end
+        end
+      end
+
+      module SQLiteColumn
+
+        def self.included(base)
+          base.alias_method_chain :default_function, :sqlite3 if base.instance_methods.include? :default_function
+        end
+
+        def default_function_with_sqlite3
+          @default_function ||= "(#{default})" if default =~ /DATETIME/
+          default_function_without_sqlite3
+        end
+      end
+    end
+  end
+end

data/lib/schema_default_expr/middleware.rb

@@ -0,0 +1,54 @@
+module SchemaDefaultExpr
+  module Middleware
+    def self.insert
+      SchemaMonkey::Middleware::Migration::ColumnOptionsSql.prepend DefaultExprOptions
+      SchemaMonkey::Middleware::Dumper::Table.append DumpDefaultExpressions
+    end
+
+    class DefaultExprOptions < ::SchemaMonkey::Middleware::Base
+      def call(env)
+        options = env.options
+        if env.caller.options_include_default?(options)
+          default = options[:default]
+
+          if default.is_a? Hash and [[:expr], [:value]].include?(default.keys)
+            value = default[:value]
+            expr = env.connection.sql_for_function(default[:expr]) || default[:expr] if default[:expr]
+          else
+            value = default
+            expr = env.connection.sql_for_function(default)
+          end
+
+          if expr
+            raise ArgumentError, "Invalid default expression" unless env.connection.default_expr_valid?(expr)
+            env.sql << " DEFAULT #{expr}"
+            # must explicitly check for :null to allow change_column to work on migrations
+            if options[:null] == false
+              env.sql << " NOT NULL"
+            end
+            options.delete(:default)
+            options.delete(:null)
+          else
+            options[:default] = value
+          end
+        end
+        continue env
+      end
+    end
+
+    class DumpDefaultExpressions < SchemaMonkey::Middleware::Base
+      def call(env)
+        continue env
+        env.connection.columns(env.table.name).each do |column|
+          if !column.default_function.nil?
+            if col = env.table.columns.find{|col| col.name == column.name}
+              options = "default: { expr: #{column.default_function.inspect} }"
+              options += ", #{col.options}" unless col.options.blank?
+              col.options = options
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_pg_enums.rb

@@ -0,0 +1,6 @@
+require 'schema_monkey'
+
+require_relative 'schema_pg_enums/active_record'
+require_relative 'schema_pg_enums/middleware'
+
+SchemaMonkey.register(SchemaPgEnums)

data/lib/schema_pg_enums/active_record.rb

@@ -0,0 +1,69 @@
+module SchemaPgEnums
+  module ActiveRecord
+    module ConnectionAdapters
+      module PostgresqlAdapter
+
+        def enums
+          result = query(<<-SQL)
+            SELECT
+              N.nspname AS schema_name,
+              T.typname AS enum_name,
+              E.enumlabel AS enum_label,
+              E.enumsortorder AS enum_sort_order
+              --array_agg(E.enumlabel ORDER BY enumsortorder) AS labels
+            FROM pg_type T
+            JOIN pg_enum E ON E.enumtypid = T.oid
+            JOIN pg_namespace N ON N.oid = T.typnamespace
+            ORDER BY 1, 2, 4
+          SQL
+
+          result.reduce([]) do |res, row|
+            last = res.last
+            if last && last[0] == row[0] && last[1] == row[1]
+              last[2] << row[2]
+            else
+              res << (row[0..1] << [row[2]])
+            end
+            res
+          end
+        end
+
+        def create_enum(name, *values)
+          options = values.extract_options!
+          list = values.map { |value| escape_enum_value(value) }
+          execute "CREATE TYPE #{enum_name(name, options[:schema])} AS ENUM (#{list.join(',')})"
+        end
+
+        def alter_enum(name, value, options = {})
+          opts = case
+                 when options[:before] then "BEFORE #{escape_enum_value(options[:before])}"
+                 when options[:after] then "AFTER #{escape_enum_value(options[:after])}"
+                 else
+                   ''
+                 end
+          execute "ALTER TYPE #{enum_name(name, options[:schema])} ADD VALUE #{escape_enum_value(value)} #{opts}"
+        end
+
+        def drop_enum(name, options = {})
+          execute "DROP TYPE #{enum_name(name, options[:schema])}"
+        end
+
+        private
+
+        def enum_name(name, schema)
+          [schema || 'public', name].map { |s|
+            %Q{"#{s}"}
+          }.join('.')
+        end
+
+        def escape_enum_value(value)
+          escaped_value = value.sub("'", "''")
+          "'#{escaped_value}'"
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/schema_pg_enums/middleware.rb

@@ -0,0 +1,23 @@
+module SchemaPgEnums
+  module Middleware
+    module Postgresql
+      def self.insert
+        SchemaMonkey::Middleware::Dumper::Extensions.append CreateEnums
+      end
+
+      class CreateEnums < SchemaMonkey::Middleware::Base
+        def call(env)
+          continue env
+
+          env.connection.enums.each do |schema, name, values|
+            params = [name.inspect]
+            params << values.map(&:inspect).join(', ')
+            params << ":schema => #{schema.inspect}" if schema != 'public'
+
+            env.extensions << "create_enum #{params.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus.rb

@@ -1,22 +1,28 @@
 require 'active_record'
 require 'valuable'
 
+require 'schema_monkey'
+require 'schema_plus_indexes'
+require 'schema_plus_pg_indexes'
+
+require 'schema_column_plus'
+require 'schema_db_default'
+require 'schema_default_expr'
+require 'schema_pg_enums'
+require 'schema_views'
+require 'schema_plus_tables'
+
 require 'schema_plus/version'
-require 'schema_plus/active_record/attribute'
 require 'schema_plus/active_record/base'
-require 'schema_plus/active_record/column_options_handler'
-require 'schema_plus/active_record/db_default'
-require 'schema_plus/active_record/foreign_keys'
+require 'schema_plus/active_record/connection_adapters/abstract_adapter'
 require 'schema_plus/active_record/connection_adapters/table_definition'
 require 'schema_plus/active_record/connection_adapters/schema_statements'
 require 'schema_plus/active_record/schema'
-require 'schema_plus/active_record/schema_dumper'
-require 'schema_plus/active_record/connection_adapters/abstract_adapter'
-require 'schema_plus/active_record/connection_adapters/column'
 require 'schema_plus/active_record/connection_adapters/foreign_key_definition'
-require 'schema_plus/active_record/connection_adapters/index_definition'
 require 'schema_plus/active_record/migration/command_recorder'
-require 'schema_plus/railtie' if defined?(Rails::Railtie)
+require 'schema_plus/middleware/dumper'
+require 'schema_plus/middleware/migration'
+require 'schema_plus/middleware/model'
 
 module SchemaPlus
   module ActiveRecord
@@ -24,7 +30,6 @@ module SchemaPlus
     module ConnectionAdapters
       autoload :MysqlAdapter, 'schema_plus/active_record/connection_adapters/mysql_adapter'
       autoload :PostgresqlAdapter, 'schema_plus/active_record/connection_adapters/postgresql_adapter'
-      autoload :PostgreSQLColumn, 'schema_plus/active_record/connection_adapters/postgresql_adapter'
       autoload :Sqlite3Adapter, 'schema_plus/active_record/connection_adapters/sqlite3_adapter'
     end
   end
@@ -119,43 +124,10 @@ module SchemaPlus
     yield config
   end
 
-  def self.insert_connection_adapters #:nodoc:
-    return if @inserted_connection_adapters
-    @inserted_connection_adapters = true
-    ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter)
-    ::ActiveRecord::ConnectionAdapters::Column.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::Column)
-    ::ActiveRecord::ConnectionAdapters::IndexDefinition.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::IndexDefinition)
-    ::ActiveRecord::ConnectionAdapters::SchemaStatements.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::SchemaStatements)
-    ::ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::TableDefinition)
-    ::ActiveRecord::Migration::CommandRecorder.send(:include, SchemaPlus::ActiveRecord::Migration::CommandRecorder)
-
-    if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r >= "4.1".to_r
-      ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::AddColumnOptions)
-    else
-      ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::AddColumnOptions)
-    end
-
-    if ::ActiveRecord::VERSION::MAJOR.to_i >= 4
-      ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::VisitTableDefinition)
-    end
-
-    if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r >= "4.2".to_r
-      require 'active_record/connection_adapters/abstract_mysql_adapter'
-      ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::SchemaCreation.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::VisitTableDefinition)
-    end
-  end
-
   def self.insert #:nodoc:
-    return if @inserted
-    @inserted = true
-    insert_connection_adapters
-    ::ActiveRecord::Base.send(:include, SchemaPlus::ActiveRecord::Base)
-    ::ActiveRecord::Schema.send(:include, SchemaPlus::ActiveRecord::Schema)
-    ::ActiveRecord::SchemaDumper.send(:include, SchemaPlus::ActiveRecord::SchemaDumper)
-    ::ActiveRecord.const_set(:DB_DEFAULT, SchemaPlus::ActiveRecord::DB_DEFAULT)
-    ::ActiveRecord::Attribute.send(:include, SchemaPlus::ActiveRecord::Attribute) if defined? ::ActiveRecord::Attribute
+    SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation, SchemaPlus::ActiveRecord::ConnectionAdapters::AbstractAdapter::VisitTableDefinition
   end
 
 end
 
-SchemaPlus.insert unless defined? Rails::Railtie
+SchemaMonkey.register(SchemaPlus)