declare_schema 0.8.0.pre.6 → 0.10.1

data/lib/declare_schema/model/field_spec.rb

@@ -47,9 +47,9 @@ module DeclareSchema
       end
 
       def initialize(model, name, type, position: 0, **options)
-        defined_primary_key = model.defined_primary_key
+        _defined_primary_key = model._defined_primary_key
 
-        name.to_s == defined_primary_key and raise ArgumentError, "you may not provide a field spec for the primary key #{name.inspect}"
+        name.to_s == _defined_primary_key and raise ArgumentError, "you may not provide a field spec for the primary key #{name.inspect}"
 
         @model = model
         @name = name.to_sym
@@ -58,18 +58,21 @@ module DeclareSchema
         @position = position
         @options = options.dup
 
-        @options.has_key?(:null) or @options[:null] = false
+        @options.has_key?(:null) or @options[:null] = ::DeclareSchema.default_null
+        @options[:null].nil? and raise "null: must be provided for field #{model}##{@name}: #{@options.inspect} since ::DeclareSchema#default_null is set to 'nil'; do you want `null: false`?"
 
         case @type
         when :text
           if self.class.mysql_text_limits?
             @options[:default].nil? or raise MysqlTextMayNotHaveDefault, "when using MySQL, non-nil default may not be given for :text field #{model}##{@name}"
-            @options[:limit] = self.class.round_up_mysql_text_limit(@options[:limit] || MYSQL_LONGTEXT_LIMIT)
+            @options[:limit] ||= ::DeclareSchema.default_text_limit or
+                  raise("limit: must be provided for :text field #{model}##{@name}: #{@options.inspect} since ::DeclareSchema#default_text_limit is set to 'nil'; do you want `limit: 0xffff_ffff`?")
+            @options[:limit] = self.class.round_up_mysql_text_limit(@options[:limit])
           else
             @options.delete(:limit)
           end
         when :string
-          @options[:limit] or raise "limit: must be given for :string field #{model}##{@name}: #{@options.inspect}; do you want `limit: 255`?"
+          @options[:limit] ||= ::DeclareSchema.default_string_limit or raise "limit: must be provided for :string field #{model}##{@name}: #{@options.inspect} since ::DeclareSchema#default_string_limit is set to 'nil'; do you want `limit: 255`?"
         when :bigint
           @type = :integer
           @options[:limit] = 8
@@ -96,15 +99,15 @@ module DeclareSchema
 
         if @type.in?([:text, :string])
           if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
-            @options[:charset]   ||= model.table_options[:charset]   || Generators::DeclareSchema::Migration::Migrator.default_charset
-            @options[:collation] ||= model.table_options[:collation] || Generators::DeclareSchema::Migration::Migrator.default_collation
+            @options[:charset]   ||= model.table_options[:charset]   || ::DeclareSchema.default_charset
+            @options[:collation] ||= model.table_options[:collation] || ::DeclareSchema.default_collation
           else
             @options.delete(:charset)
             @options.delete(:collation)
           end
         else
           @options[:charset]   and warn("charset may only given for :string and :text fields for SQL type #{@type} in field #{model}##{@name}")
-          @options[:collation] and warne("collation may only given for :string and :text fields for SQL type #{@type} in field #{model}##{@name}")
+          @options[:collation] and warn("collation may only given for :string and :text fields for SQL type #{@type} in field #{model}##{@name}")
         end
 
         @options = Hash[@options.sort_by { |k, _v| OPTION_INDEXES[k] || 9999 }]

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -7,14 +7,15 @@ module DeclareSchema
     class ForeignKeyDefinition
       include Comparable
 
-      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :options, :on_delete_cascade
+      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :parent_table_name, :child_table_name, :options, :on_delete_cascade
+
 
       def initialize(model, foreign_key, options = {})
         @model = model
         @foreign_key = foreign_key.to_s.presence
         @options = options
 
-        @child_table = model.table_name # unless a table rename, which would happen when a class is renamed??
+        @child_table_name = model.table_name # unless a table rename, which would happen when a class is renamed??
         @parent_table_name = options[:parent_table]&.to_s
         @foreign_key_name = options[:foreign_key]&.to_s || @foreign_key
 
@@ -61,11 +62,6 @@ module DeclareSchema
             foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
       end
 
-      def to_add_statement
-        "add_foreign_key(#{@child_table.inspect}, #{parent_table_name.inspect}, " +
-          "column: #{@foreign_key_name.inspect}, name: #{@constraint_name.inspect})"
-      end
-
       def <=>(rhs)
         key <=> rhs.send(:key)
       end
@@ -75,7 +71,7 @@ module DeclareSchema
       private
 
       def key
-        @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
+        @key ||= [@child_table_name, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
       end
 
       def hash

data/lib/declare_schema/model/habtm_model_shim.rb

@@ -47,7 +47,7 @@ module DeclareSchema
         false # no single-column primary key in database
       end
 
-      def defined_primary_key
+      def _defined_primary_key
         false # no single-column primary key declared
       end
 

data/lib/declare_schema/model/index_definition.rb

@@ -93,25 +93,6 @@ module DeclareSchema
         name == PRIMARY_KEY_NAME
       end
 
-      def to_add_statement(new_table_name, existing_primary_key = nil)
-        if primary_key? && !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
-          to_add_primary_key_statement(new_table_name, existing_primary_key)
-        else
-          # Note: + below keeps that interpolated string from being frozen, so we can << into it.
-          r = +"add_index #{new_table_name.to_sym.inspect}, #{fields.map(&:to_sym).inspect}"
-          r << ", unique: true"      if unique
-          r << ", where: '#{where}'" if where.present?
-          r << ", name: '#{name}'"
-          r
-        end
-      end
-
-      def to_add_primary_key_statement(new_table_name, existing_primary_key)
-        drop = "DROP PRIMARY KEY, " if existing_primary_key
-        statement = "ALTER TABLE #{new_table_name} #{drop}ADD PRIMARY KEY (#{fields.join(', ')})"
-        "execute #{statement.inspect}"
-      end
-
       def to_key
         @key ||= [table, fields, name, unique, where].map(&:to_s)
       end

data/lib/declare_schema/schema_change/all.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module SchemaChange
+    module All
+    end
+    autoload :Base, 'declare_schema/schema_change/base'
+    autoload :ColumnAdd, 'declare_schema/schema_change/column_add'
+    autoload :ColumnChange, 'declare_schema/schema_change/column_change'
+    autoload :ColumnRename, 'declare_schema/schema_change/column_rename'
+    autoload :ForeignKeyAdd, 'declare_schema/schema_change/foreign_key_add'
+    autoload :ForeignKeyRemove, 'declare_schema/schema_change/foreign_key_remove'
+    autoload :IndexAdd, 'declare_schema/schema_change/index_add'
+    autoload :IndexRemove, 'declare_schema/schema_change/index_remove'
+    autoload :PrimaryKeyChange, 'declare_schema/schema_change/primary_key_change'
+    autoload :TableAdd, 'declare_schema/schema_change/table_add'
+    autoload :TableChange, 'declare_schema/schema_change/table_change'
+    autoload :TableRemove, 'declare_schema/schema_change/table_remove'
+    autoload :TableRename, 'declare_schema/schema_change/table_rename'
+  end
+end
+

data/lib/declare_schema/schema_change/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module DeclareSchema
+  module SchemaChange
+    class Base
+      class << self
+        def format_options(options)
+          options.map do |k, v|
+            value =
+              if v.is_a?(Hash)
+                "{ #{format_options(v).join(', ')} }"
+              else
+                v.inspect
+              end
+            if k.is_a?(Symbol)
+              "#{k}: #{value}"
+            else
+              "#{k.inspect} => #{value}"
+            end
+          end
+        end
+      end
+
+      def up
+        up_command + spacing(up_command)
+      end
+
+      def down
+        down_command + spacing(down_command)
+      end
+
+      private
+
+      def spacing(command)
+        if command["\n"]
+          "\n\n"
+        else
+          "\n"
+        end
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/column_add.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module DeclareSchema
+  module SchemaChange
+    class ColumnAdd < Base
+      def initialize(table_name, column_name, column_type, **column_options)
+        @table_name = table_name
+        @column_name = column_name
+        @column_type = column_type
+        @column_options = column_options
+      end
+
+      def up_command
+        "add_column #{[@table_name.to_sym.inspect,
+                       @column_name.to_sym.inspect,
+                       @column_type.to_sym.inspect,
+                       *self.class.format_options(@column_options)].join(", ")}"
+      end
+
+      def down_command
+        "remove_column #{@table_name.to_sym.inspect}, #{@column_name.to_sym.inspect}"
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/column_change.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module DeclareSchema
+  module SchemaChange
+    class ColumnChange < Base
+      def initialize(table_name, column_name, old_type:, old_options:, new_type:, new_options:)
+        @table_name = table_name
+        @column_name = column_name
+        @old_type = old_type
+        @old_options = old_options
+        @new_type = new_type
+        @new_options = new_options
+      end
+
+      def up_command
+        "change_column #{[@table_name.to_sym.inspect,
+                          @column_name.to_sym.inspect,
+                          @new_type.to_sym.inspect,
+                          *self.class.format_options(@new_options)].join(", ")}"
+      end
+
+      def down_command
+        "change_column #{[@table_name.to_sym.inspect,
+                          @column_name.to_sym.inspect,
+                          @old_type.to_sym.inspect,
+                          *self.class.format_options(@old_options)].join(", ")}"
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/column_remove.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'column_add'
+
+module DeclareSchema
+  module SchemaChange
+    class ColumnRemove < ColumnAdd
+      alias column_add_up_command up_command
+      alias column_add_down_command down_command
+
+      def up_command
+        column_add_down_command
+      end
+
+      def down_command
+        column_add_up_command
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/column_rename.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module DeclareSchema
+  module SchemaChange
+    class ColumnRename < Base
+      def initialize(table_name, old_name, new_name)
+        @table_name = table_name
+        @old_name = old_name
+        @new_name = new_name
+      end
+
+      def up_command
+        "rename_column #{@table_name.to_sym.inspect}, #{@old_name.to_sym.inspect}, #{@new_name.to_sym.inspect}"
+      end
+
+      def down_command
+        "rename_column #{@table_name.to_sym.inspect}, #{@new_name.to_sym.inspect}, #{@old_name.to_sym.inspect}"
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/foreign_key_add.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module DeclareSchema
+  module SchemaChange
+    class ForeignKeyAdd < Base
+      def initialize(table_name, parent_table_name, column_name:, name:)
+        @table_name = table_name
+        @parent_table_name = parent_table_name
+        @column_name = column_name
+        @name = name
+      end
+
+      def up_command
+        "add_foreign_key #{@table_name.to_sym.inspect}, #{@parent_table_name.to_sym.inspect}, " +
+          "column: #{@column_name.to_sym.inspect}, name: #{@name.to_sym.inspect}"
+      end
+
+      def down_command
+        "remove_foreign_key #{@table_name.to_sym.inspect}, name: #{@name.to_sym.inspect}"
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/foreign_key_remove.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'foreign_key_add'
+
+module DeclareSchema
+  module SchemaChange
+    class ForeignKeyRemove < ForeignKeyAdd
+      alias index_add_up_command up_command
+      alias index_add_down_command down_command
+
+      def up_command
+        index_add_down_command
+      end
+
+      def down_command
+        index_add_up_command
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/index_add.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module DeclareSchema
+  module SchemaChange
+    class IndexAdd < Base
+      def initialize(table_name, column_names, name:, unique:, where: nil)
+        @table_name = table_name
+        @column_names = column_names
+        @name = name
+        @unique = unique
+        @where = where.presence
+      end
+
+      def up_command
+        options = {
+          name: @name.to_sym,
+        }
+        options[:unique] = true if @unique
+        options[:where] = @where if @where
+
+        "add_index #{[@table_name.to_sym.inspect,
+                      @column_names.map(&:to_sym).inspect,
+                      *self.class.format_options(options)].join(', ')}"
+      end
+
+      def down_command
+        "remove_index #{@table_name.to_sym.inspect}, name: #{@name.to_sym.inspect}"
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/index_remove.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'index_add'
+
+module DeclareSchema
+  module SchemaChange
+    class IndexRemove < IndexAdd
+      alias index_add_up_command up_command
+      alias index_add_down_command down_command
+
+      def up_command
+        index_add_down_command
+      end
+
+      def down_command
+        index_add_up_command
+      end
+    end
+  end
+end

data/lib/declare_schema/schema_change/primary_key_change.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module DeclareSchema
+  module SchemaChange
+    class PrimaryKeyChange < Base
+      def initialize(table_name, old_column_names, new_column_names)
+        @table_name = table_name
+        @old_column_names = old_column_names.presence
+        @new_column_names = new_column_names.presence
+      end
+
+      def up_command
+        alter_primary_key(@old_column_names, @new_column_names)
+      end
+
+      def down_command
+        alter_primary_key(@new_column_names, @old_column_names)
+      end
+
+      private
+
+      def alter_primary_key(old_col_names, new_col_names)
+        drop_command = "DROP PRIMARY KEY" if old_col_names
+        add_command = "ADD PRIMARY KEY (#{new_col_names.join(', ')})" if new_col_names
+        commands = [drop_command, add_command].compact.join(', ')
+        statement = "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(@table_name)} #{commands}"
+        "execute #{statement.inspect}"
+      end
+    end
+  end
+end