localtower 1.0.0 → 2.0.1

data/lib/localtower/generators/migration.rb

@@ -1,18 +1,28 @@
+#
+# @see https://github.com/rails/rails/blob/main/activerecord/lib/active_record/migration.rb
+# @see https://github.com/rails/rails/blob/main/activerecord/lib/active_record/migration/command_recorder.rb
+# @see https://api.rubyonrails.org/v7.2.1/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html
+#
 module Localtower
   module Generators
     class ThorGeneratorMigration < Thor
+      SPACE_PADDING = "    "
+
       include Thor::Base
       include Thor::Actions
 
       no_commands do
         def migration_add_column(data)
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No attribute name provided" if data['column_name'].blank?
+
           # Special case for array
           if %w[array].include?(data["column_type"])
-            line  = "    add_column :#{data['table_name']}, :#{data['column']}, :string"
-            line << ", default: []"
+            line  = "#{SPACE_PADDING}add_column :#{data['table_name']}, :#{data['column_name']}, :string"
+            line << ", default: #{data['default']}" if data['default'].present?
             line << ", array: true"
           else
-            line  = "    add_column :#{data['table_name']}, :#{data['column']}, :#{data['column_type']}"
+            line  = "#{SPACE_PADDING}add_column :#{data['table_name']}, :#{data['column_name']}, :#{data['column_type']}"
             line << ", default: #{data['default']}" if data['default'].present?
             line << ", null: false" if data['nullable'] == false
           end
@@ -20,71 +30,86 @@ module Localtower
           line << "\n"
 
           inject_in_migration(file, line)
+
+          if data["index"].present?
+            migration_add_index_to_column(data)
+          end
         end
 
         def migration_remove_column(data)
-          line = "    remove_column :#{data['table_name']}, :#{data['column']}\n"
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No attribute name provided" if data['column_name'].blank?
+
+          line = "#{SPACE_PADDING}remove_column :#{data['table_name']}, :#{data['column_name']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_rename_column(data)
-          line = "    rename_column :#{data['table_name']}, :#{data['column']}, :#{data['new_column_name']}\n"
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No attribute name provided" if data['column_name'].blank?
+          raise "No new attribute name provided" if data['new_column_name'].blank?
+
+          line = "#{SPACE_PADDING}rename_column :#{data['table_name']}, :#{data['column_name']}, :#{data['new_column_name']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_change_column_type(data)
-          line = "    change_column :#{data['table_name']}, :#{data['column']}, :#{data['new_column_type']}\n"
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No attribute name provided" if data['column_name'].blank?
+          raise "No new attribute type provided" if data['new_column_type'].blank?
+
+          line = "#{SPACE_PADDING}change_column :#{data['table_name']}, :#{data['column_name']}, :#{data['new_column_type']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_add_index_to_column(data)
-          line = "    add_index :#{data['table_name']}, :#{data['column']}\n"
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No attribute name provided" if data['column_name'].blank?
+          raise "No index provided" if data['index'].blank?
+
+          line = "#{SPACE_PADDING}add_index :#{data['table_name']}, :#{data['column_name']}\n"
 
           inject_in_migration(file, line)
 
           # Custom options:
           params = [data]
-          .select { |attr| attr.dig('index', 'using').present? }
-          .reject { |attr| attr.dig('index', 'using') == 'none' }
-          .each_with_object([]) do |attr, arr|
-            arr << Hash[attr['column'], attr['index']]
+                    .select { |attr| attr["index"].present? }
+                    .each_with_object([]) do |attr, arr|
+            arr << Hash[attr['column_name'],
+                        { "using" => attr['index'], "algorithm" => attr['index_algorithm'], "unique" => attr['unique'] }]
           end
           ::Localtower::Generators::ServiceObjects::InsertIndexes.new(params).call
         end
 
         def migration_remove_index_to_column(data)
-          line = "    remove_index :#{data['table_name']}, :#{data['column']}\n"
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No index_name provided" if data['index_name'].blank?
+
+          line = "#{SPACE_PADDING}remove_index :#{data['table_name']}, name: :#{data['index_name']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_belongs_to(data)
-          line = "    add_reference :#{data['table_name']}, :#{data['column']}, foreign_key: true, index: true\n"
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No attribute name provided" if data['column_name'].blank?
 
-          inject_in_migration(file, line)
-
-          file = "#{Rails.root}/app/models/#{data['table_name'].underscore.singularize}.rb"
-          after = /class #{data["table_name"].camelize.singularize} < ApplicationRecord\n/
-          line1 = "  # belongs_to :#{data['column'].singularize.underscore}\n"
+          line = "#{SPACE_PADDING}add_reference :#{data['table_name']}, :#{data['column_name']}"
 
-          if File.exist?(file)
-            ::Localtower::Tools::ThorTools.new.insert_after_word(file, after, line1)
-          end
-
-          file = "#{Rails.root}/app/models/#{data['column'].underscore.singularize}.rb"
-          after = /class #{data["column"].camelize.singularize} < ApplicationRecord\n/
-          line1 = "  # has_many :#{data['table_name'].pluralize.underscore}\n"
+          line << ", foreign_key: true" if data['foreign_key'].present?
+          line << ", index: true"
+          line << "\n"
 
-          if File.exist?(file)
-            ::Localtower::Tools::ThorTools.new.insert_after_word(file, after, line1)
-          end
+          inject_in_migration(file, line)
         end
 
         def migration_drop_table(data)
-          line = "    drop_table :#{data['table_name']}\n"
+          raise "No table name provided" if data['table_name'].blank?
+
+          line = "#{SPACE_PADDING}drop_table :#{data['table_name']}\n"
 
           inject_in_migration(file, line)
         end
@@ -96,90 +121,192 @@ module Localtower
         end
 
         def file
-          Localtower::Tools.last_migration
+          Localtower::Tools.last_migration_pending
         end
       end
     end
 
     class Migration
-      TYPES = %w[string datetime date text uuid integer float json jsonb decimal binary boolean array references].freeze
-      ACTIONS = %w[
-        add_column
-        add_index_to_column
-        remove_index_to_column
-        belongs_to
-        remove_column
-        change_column_type
-        rename_column
-        drop_table
-      ].freeze
+      TYPES = [
+        {
+          name: "string",
+          example: "'foo'",
+        },
+        {
+          name: "text",
+          example: "'long foo'",
+        },
+        {
+          name: "datetime",
+          example: "2024-07-22 12:28:31.487318",
+        },
+        {
+          name: "date",
+          example: "2024-09-24",
+        },
+        {
+          name: "uuid",
+          example: "'860f5e00-0000-0000-0000-000000000000'",
+        },
+        {
+          name: "integer",
+          example: "123",
+        },
+        {
+          name: "bigint",
+          example: "123",
+        },
+        {
+          name: "float",
+          example: "30.12",
+        },
+        {
+          name: "numeric",
+          example: "30.12",
+        },
+        {
+          name: "decimal",
+          example: "30.12",
+        },
+        {
+          name: "json",
+          example: "{\"foo\": \"bar\"}",
+        },
+        {
+          name: "jsonb",
+          example: "{\"foo\": \"bar\"}",
+        },
+        {
+          name: "binary",
+          example: "01010001",
+        },
+        {
+          name: "boolean",
+          example: "true/false",
+        },
+        {
+          name: "array",
+          example: "[1, 2, 3]",
+        },
+        {
+          name: "blob",
+          example: "x3F7F2A9",
+        },
+        {
+          name: "references",
+          example: "MyModel",
+        }
+      ]
+
+      ACTIONS = [
+        {
+          name: "add_column",
+          label: "Add column",
+          example: "add_column :users, :name, :string",
+        },
+        {
+          name: "add_index_to_column",
+          label: "Add index",
+          example: "add_index :users, :name",
+        },
+        {
+          name: "belongs_to",
+          label: "Add reference",
+          example: "add_reference :posts, :user",
+        },
+        {
+          name: "remove_index_to_column",
+          label: "Remove index",
+          example: "remove_index :users, :name",
+        },
+        {
+          name: "remove_column",
+          label: "Remove column",
+          example: "remove_column :users, :name",
+        },
+        {
+          name: "change_column_type",
+          label: "Change column type",
+          example: "change_column :users, :name, :string",
+        },
+        {
+          name: "rename_column",
+          label: "Rename column",
+          example: "rename_column :users, :name, :new_name",
+        },
+        {
+          name: "drop_table",
+          label: "Drop table",
+          example: "drop_table :users",
+        }
+      ]
 
       # @opts =
-      def initialize(migrations)
+      def initialize(migrations, migration_name = nil)
         @thor = ThorGeneratorMigration.new
+
+        # stringify keys:
         @migrations = JSON[migrations.to_json]
+        @migration_name = migration_name
       end
 
+      # const DEFAULT_LINE = {
+      #   model_name: MODELS[0] ? MODELS[0].value : '',
+      #   table_name: MODELS[0] ? MODELS[0].table_name : '',
+      #   action_name: 'add_column',
+      #   column_type: 'string',
+      #   column_name: '',
+      #   new_column_name: '',
+      #   new_column_type: '',
+      #   default: '',
+      #   unique: false,
+      #   foreign_key: false,
+      #   index: '',
+      #   index_algorithm: 'default',
+      #   index_name: '',
+      #   nullable: true
+      # };
+
       def run
-        model_names = migrations.map { |line| line['table_name'].camelize }.uniq.join
+        if Localtower::Tools.pending_migrations.any?
+          # raise "There is a pending migration. You can't generate a migration until the pending migration is committed."
+        else
+          migration_name_final = if @migration_name.present?
+            @migration_name
+          else
+            action_names = migrations.map { |line| line['action_name'].camelize }.uniq.take(1).join
+            model_names = migrations.map { |line| line['model_name'].camelize }.uniq.take(2).join
+            column_names = migrations.map { |line| (line['column_name'].presence || "").camelize }.uniq.take(2).join
 
-        cmd = "Change#{model_names}At#{Time.now.to_i}"
-        ::Localtower::Tools.perform_migration(cmd)
+            "#{action_names}#{column_names}For#{model_names}"
+          end
 
-        migrations.each do |action_line|
-          next if action_line['action'].blank?
-
-          {
-            'add_column' => -> { add_column(action_line) },
-            'remove_column' => -> { remove_column(action_line) },
-            'rename_column' => -> { rename_column(action_line) },
-            'change_column_type' => -> { change_column_type(action_line) },
-            'add_index_to_column' => -> { add_index_to_column(action_line) },
-            'belongs_to' => -> { belongs_to(action_line) },
-            'remove_index_to_column' => -> { remove_index_to_column(action_line) },
-            'drop_table' => -> { drop_table(action_line) }
-          }[action_line['action']].call
+          ::Localtower::Tools.perform_migration(migration_name_final)
         end
-      end
 
-      private
-
-      attr_reader :migrations
-
-      def add_column(data)
-        @thor.migration_add_column(data)
-      end
-
-      def remove_column(data)
-        @thor.migration_remove_column(data)
-      end
+        migrations.each do |action_line|
+          next if action_line['action_name'].blank?
 
-      def rename_column(data)
-        @thor.migration_rename_column(data)
-      end
+          # action_line['table_name'] = action_line['model_name'].pluralize.underscore
 
-      def change_column_type(data)
-        @thor.migration_change_column_type(data)
-      end
-
-      def add_index_to_column(data)
-        @thor.migration_add_index_to_column(data)
-      end
+          proc_var = {
+            'add_column' => -> { thor.migration_add_column(action_line) },
+            'remove_column' => -> { thor.migration_remove_column(action_line) },
+            'rename_column' => -> { thor.migration_rename_column(action_line) },
+            'change_column_type' => -> { thor.migration_change_column_type(action_line) },
+            'add_index_to_column' => -> { thor.migration_add_index_to_column(action_line) },
+            'belongs_to' => -> { thor.migration_belongs_to(action_line) },
+            'remove_index_to_column' => -> { thor.migration_remove_index_to_column(action_line) },
+            'drop_table' => -> { thor.migration_drop_table(action_line) }
+          }[action_line['action_name']]
 
-      def belongs_to(data)
-        data["column"] = data["belongs_to"].underscore.singularize
-        data['column_type'] = "references"
+          raise "No proc found for action_name #{action_line['action_name']}" unless proc_var
 
-        @thor.migration_belongs_to(data)
-      end
-
-      def remove_index_to_column(data)
-        @thor.migration_remove_index_to_column(data)
+          proc_var.call
+        end
       end
 
-      def drop_table(data)
-        @thor.migration_drop_table(data)
-      end
+      attr_reader :thor, :migrations
     end
   end
 end

data/lib/localtower/generators/model.rb

@@ -12,45 +12,44 @@ module Localtower
 
       def run
         attributes_str = parse_attributes.join(" ")
-        cmd = "rails generate model #{model_name.camelize} #{attributes_str}"
-
+        cmd = "rails generate model #{model_name.camelize} #{attributes_str} --force"
         ::Localtower::Tools.perform_cmd(cmd)
 
         insert_non_nullable_values
         insert_default_values
         insert_array
         insert_indexes
+        insert_foreign_keys
       end
 
       private
 
-      attr_reader :model_name
-      attr_reader :attributes
+      attr_reader :model_name, :attributes
 
       def parse_attributes
         attributes.map do |attr_hash|
           [
-            attr_hash['attribute_name'],
-            (attr_hash['attribute_type'] == 'array' ? 'string' : attr_hash['attribute_type']), # we need this transformation of "array"
-            (attr_hash.dig('index', 'using') != 'none') ? 'index' : nil
+            attr_hash['column_name'],
+            # we need this transformation of "array":
+            (attr_hash['column_type'] == 'array' ? 'string' : attr_hash['column_type']),
+            attr_hash["index"].present? ? 'index' : nil
           ].compact.join(':')
         end
       end
 
       def insert_array
         params = attributes
-          .select { |attr| attr['attribute_type'] == 'array' }
-          .map { |attr| attr['attribute_name'] }
+                 .select { |attr| attr['column_type'] == 'array' }
+                 .map { |attr| attr['column_name'] }
 
         Localtower::Generators::ServiceObjects::InsertArray.new(params).call
       end
 
       def insert_default_values
         params = attributes
-          .reject { |attr| attr['default'] == nil }
-          .reject { |attr| attr['default'] == '' }
-          .each_with_object([]) do |attr, arr|
-          arr << Hash[attr['attribute_name'], attr['default']]
+                 .select { |attr| attr['default'].present? }
+                 .each_with_object([]) do |attr, arr|
+          arr << Hash[attr['column_name'], attr['default']]
         end
 
         Localtower::Generators::ServiceObjects::InsertDefaults.new(params).call
@@ -58,22 +57,32 @@ module Localtower
 
       def insert_non_nullable_values
         params = attributes
-          .select { |attr| attr['nullable'] == false }
-          .map{ |attr| attr['attribute_name'] }
+                 .select { |attr| attr['nullable'] == false }
+                 .map { |attr| attr['column_name'] }
 
         ::Localtower::Generators::ServiceObjects::InsertNullable.new(params).call
       end
 
       def insert_indexes
         params = attributes
-          .select { |attr| attr.dig('index', 'using').present? }
-          .reject { |attr| attr.dig('index', 'using') == 'none' }
-          .each_with_object([]) do |attr, arr|
-            arr << Hash[attr['attribute_name'], attr['index']]
-          end
+                 .select { |attr| attr["index"].present? }
+                 .each_with_object([]) do |attr, arr|
+          arr << Hash[attr['column_name'],
+                      { "using" => attr['index'], "algorithm" => attr['index_algorithm'], "unique" => attr['unique'] }]
+        end
 
         ::Localtower::Generators::ServiceObjects::InsertIndexes.new(params).call
       end
+
+      def insert_foreign_keys
+        params = attributes
+                 .each_with_object([]) do |attr, arr|
+          arr << Hash[attr['column_name'],
+                      { "foreign_key" => attr['foreign_key'] }]
+        end
+
+        ::Localtower::Generators::ServiceObjects::InsertForeignKeys.new(params).call
+      end
     end
   end
 end

data/lib/localtower/generators/service_objects/insert_array.rb

@@ -8,9 +8,11 @@ module Localtower
 
         def call
           attributes.each do |attribute|
-            line_str = File.read(Localtower::Tools.last_migration).match(/((.*)t\.string :#{attribute})/)[0]
-            content = File.read(Localtower::Tools.last_migration).gsub(line_str, "#{line_str}, array: true")
-            File.write(Localtower::Tools.last_migration, content)
+            line_str = Localtower::Tools.line_for_attribute(attribute)[0]
+            if line_str.present?
+              content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, "#{line_str}, array: true")
+              File.write(Localtower::Tools.last_migration_pending, content)
+            end
           end
         end
 

data/lib/localtower/generators/service_objects/insert_defaults.rb

@@ -13,6 +13,74 @@ module Localtower
           'nil' => 'nil',
         }
 
+        DEFAULT_VALUES = {
+          'NULL' => { value: '', label: 'NULL', example: 'NULL' },
+          'EMPTY_STRING' => { value: "''", label: 'Empty string', example: "''" },
+          'NOW_DATETIME' => { value: "'now()'", label: 'Current datetime', example: 'now()' },
+          'NOW_DATE' => { value: "'now()'", label: 'Current date', example: 'now()' },
+          'ZERO' => { value: "0", label: 'Zero', example: '0' },
+          'JSON' => { value: "{}", label: 'Empty JSON', example: '{}' }
+        }
+
+        DEFAULTS_BY_TYPE = {
+          string: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['EMPTY_STRING']
+          ],
+          text: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['EMPTY_STRING']
+          ],
+          datetime: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['NOW_DATETIME']
+          ],
+          date: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['NOW_DATE']
+          ],
+          uuid: [
+            DEFAULT_VALUES['NULL']
+          ],
+          integer: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          bigint: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          float: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          numeric: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          decimal: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          json: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['JSON']
+          ],
+          jsonb: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['JSON']
+          ],
+          boolean: [
+            DEFAULT_VALUES['NULL'],
+            { value: 'true', label: 'True', example: 'true' },
+            { value: 'false', label: 'False', example: 'false' }
+          ],
+          array: [
+            DEFAULT_VALUES['NULL'],
+            { value: '[]', label: 'Empty array', example: '[]' }
+          ]
+        }
+
         def initialize(attributes)
           @attributes = attributes
         end
@@ -20,9 +88,11 @@ module Localtower
         def call
           attributes.each do |attribute|
             attribute.each do |attr_key, attr_value|
-              line_str = File.read(Localtower::Tools.last_migration).match(/((.*)t\.(.*)\:#{attr_key})/)[0]
-              content = File.read(Localtower::Tools.last_migration).gsub(line_str, "#{line_str}, default: #{attr_value}")
-              File.write(Localtower::Tools.last_migration, content)
+              line_str = Localtower::Tools.line_for_attribute(attr_key)[0]
+              if line_str.present?
+                content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, "#{line_str}, default: #{attr_value}")
+                File.write(Localtower::Tools.last_migration_pending, content)
+              end
             end
           end
         end

data/lib/localtower/generators/service_objects/insert_foreign_keys.rb

@@ -0,0 +1,35 @@
+module Localtower
+  module Generators
+    module ServiceObjects
+      class InsertForeignKeys
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def call
+          attributes.each do |attribute|
+            attribute.each do |attr_key, options|
+              line_str = Localtower::Tools.line_for_attribute(attr_key)[0]
+              if line_str.present?
+                if options['foreign_key'].present?
+                  if line_str['foreign_key: true']
+                    content = File.read(Localtower::Tools.last_migration_pending)
+                  else
+                    content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, "#{line_str}, foreign_key: true")
+                  end
+                else
+                  content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, line_str.gsub(', foreign_key: true', ''))
+                end
+                File.write(Localtower::Tools.last_migration_pending, content)
+              end
+            end
+          end
+        end
+
+        private
+
+        attr_reader :attributes
+      end
+    end
+  end
+end