localtower 0.4.2 → 1.0.0

data/lib/localtower/generators/migration.rb

@@ -6,21 +6,15 @@ module Localtower
 
       no_commands do
         def migration_add_column(data)
-          file = data["last_migration_file"]
-
-          if %w(array).include?(data["column_type"])
-            line  = "    add_column :#{data['table_name']}, :#{data['column']}, :text"
+          # Special case for array
+          if %w[array].include?(data["column_type"])
+            line  = "    add_column :#{data['table_name']}, :#{data['column']}, :string"
             line << ", default: []"
             line << ", array: true"
-
-            # Add an gin inde as well:
-            line << "\n"
-            line << "    add_index :#{data['table_name']}, :#{data['column']}, using: :gin"
           else
             line  = "    add_column :#{data['table_name']}, :#{data['column']}, :#{data['column_type']}"
             line << ", default: #{data['default']}" if data['default'].present?
-            line << ", null: false" if not data['nullable']
-            line << ", index: true" if data['index'] == true
+            line << ", null: false" if data['nullable'] == false
           end
 
           line << "\n"
@@ -29,90 +23,68 @@ module Localtower
         end
 
         def migration_remove_column(data)
-          file = data['last_migration_file']
-
           line = "    remove_column :#{data['table_name']}, :#{data['column']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_rename_column(data)
-          file = data['last_migration_file']
-
           line = "    rename_column :#{data['table_name']}, :#{data['column']}, :#{data['new_column_name']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_change_column_type(data)
-          file = data['last_migration_file']
-
           line = "    change_column :#{data['table_name']}, :#{data['column']}, :#{data['new_column_type']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_add_index_to_column(data)
-          file = data['last_migration_file']
-
-          line = "    add_index :#{data["table_name"]}, :#{data["column"]}\n"
+          line = "    add_index :#{data['table_name']}, :#{data['column']}\n"
 
           inject_in_migration(file, line)
-        end
-
-        # def migration_add_index_to_column_combined(data)
-        #   file = data["last_migration_file"]
-        #   attr_names = data["column"].split(",")
 
-        #   #     add_index :relationships, [:follower_id, :followed_id], unique: true
-        #   line = "    add_index :#{data["table_name"]}, [#{attr_names.map { |i| ":#{i}"}.join(', ')}]"
-        #   line << ", unique: true" if data["unique"]
-        #   line << "\n"
-
-        #   inject_in_migration(file, line)
-        # end
+          # 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']]
+          end
+          ::Localtower::Generators::ServiceObjects::InsertIndexes.new(params).call
+        end
 
         def migration_remove_index_to_column(data)
-          file = data["last_migration_file"]
-
-          line = "    remove_index :#{data["table_name"]}, :#{data["column"]}\n"
+          line = "    remove_index :#{data['table_name']}, :#{data['column']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_belongs_to(data)
-          file = data["last_migration_file"]
-
-          line = "    add_reference :#{data["table_name"]}, :#{data["column"]}, foreign_key: true, index: true\n"
+          line = "    add_reference :#{data['table_name']}, :#{data['column']}, foreign_key: true, index: true\n"
 
           inject_in_migration(file, line)
 
-          file = "#{Rails.root}/app/models/#{data["table_name"].underscore.singularize}.rb"
+          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"
-
-          ::Localtower::Tools::ThorTools.new.insert_after_word(file, after, line1)
+          line1 = "  # belongs_to :#{data['column'].singularize.underscore}\n"
 
+          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"
+          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"
+          line1 = "  # has_many :#{data['table_name'].pluralize.underscore}\n"
 
-          ::Localtower::Tools::ThorTools.new.insert_after_word(file, after, line1)
-        end
-
-        def migration_create_table(data)
-          file = data["last_migration_file"]
-
-          line = "    create_table :#{data["table_name"]}\n"
-
-          inject_in_migration(file, line)
+          if File.exist?(file)
+            ::Localtower::Tools::ThorTools.new.insert_after_word(file, after, line1)
+          end
         end
 
         def migration_drop_table(data)
-          file = data["last_migration_file"]
-
-          line = "    drop_table :#{data["table_name"]}, force: :cascade\n"
+          line = "    drop_table :#{data['table_name']}\n"
 
           inject_in_migration(file, line)
         end
@@ -120,66 +92,42 @@ module Localtower
         private
 
         def inject_in_migration(file, line)
-          inject_into_file(file, line,  after: "def change\n")
+          inject_into_file(file, line, before: "  end\nend")
+        end
+
+        def file
+          Localtower::Tools.last_migration
         end
       end
     end
 
     class Migration
-      TYPES = %w(string datetime text uuid integer float json jsonb decimal binary boolean array references).freeze
-      ACTIONS = [
-        'add_column',
-        'remove_column',
-        'rename_column',
-        'change_column_type',
-        'add_index_to_column',
-        'belongs_to',
-        # 'add_index_to_column_combined',
-        'remove_index_to_column',
-        # 'create_table',
-        'drop_table',
+      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
 
-      DEFAULTS = [
-        "true", "false", "nil"
-      ]
-
       # @opts =
-      def initialize(opts)
+      def initialize(migrations)
         @thor = ThorGeneratorMigration.new
-        @opts = JSON[opts.to_json]
+        @migrations = JSON[migrations.to_json]
       end
 
-      def remove_all_migrations
-        Dir["#{Rails.root}/db/migrate/*"].each { |migration_file| File.delete(migration_file) }
+      def run
+        model_names = migrations.map { |line| line['table_name'].camelize }.uniq.join
 
-        content_schema = """
-ActiveRecord::Schema.define(version: 0) do
-end
-        """
+        cmd = "Change#{model_names}At#{Time.now.to_i}"
+        ::Localtower::Tools.perform_migration(cmd)
 
-        File.open("#{Rails.root}/db/schema.rb", "w") do |f|
-          f.write(content_schema)
-        end
-      end
-
-      def run
-        cmd = "ChangeTheModel#{@opts['migration_name']}AtTime#{Time.now.to_i}"
-        ::Localtower::Tools.perform_migration(cmd, true)
-
-        @opts['migrations'].each do |action_line|
-          next unless action_line['action'].present?
-
-          # table_name = action_line['table_name']
-          # column = action_line['column']
-          # index = action_line['index']
-          # default = action_line['default']
-          # null = action_line['null']
-          # unique = action_line['unique']
-          # column_type = action_line['column_type']
-          # new_column_type = action_line['new_column_type']
-          # new_column_name = action_line['new_column_name']
-          action_line["last_migration_file"] = last_migration_file
+        migrations.each do |action_line|
+          next if action_line['action'].blank?
 
           {
             'add_column' => -> { add_column(action_line) },
@@ -188,126 +136,50 @@ end
             'change_column_type' => -> { change_column_type(action_line) },
             'add_index_to_column' => -> { add_index_to_column(action_line) },
             'belongs_to' => -> { belongs_to(action_line) },
-            # 'add_index_to_column_combined' => -> { add_index_to_column_combined(action_line) },
             'remove_index_to_column' => -> { remove_index_to_column(action_line) },
-            'create_table' => -> { create_table(action_line) },
             'drop_table' => -> { drop_table(action_line) }
-            }[action_line['action'].downcase].call
+          }[action_line['action']].call
         end
-
-        if @opts['run_migrate']
-          run_migration_or_nil
-        end
-      end
-
-      #====================================
-      def last_migration_file
-        Dir["#{Rails.root}/db/migrate/*"].sort.last
       end
 
-      # VALIDATION before continuing:
       private
 
-      def add_column(data)
-        if not data["table_name"].present? \
-          or not data["column"].present? \
-          or not data["column_type"].present?
-          return nil
-        end
+      attr_reader :migrations
 
+      def add_column(data)
         @thor.migration_add_column(data)
       end
 
       def remove_column(data)
-        if not data["table_name"].present? \
-          or not data["column"].present?
-          return nil
-        end
-
         @thor.migration_remove_column(data)
       end
 
       def rename_column(data)
-        if not data["table_name"].present? \
-          or not data["column"].present? \
-          or not data["new_column_name"].present?
-          return nil
-        end
-
         @thor.migration_rename_column(data)
       end
 
       def change_column_type(data)
-        if not data["table_name"].present? \
-          or not data["column"].present? \
-          or not data["new_column_type"].present?
-          return nil
-        end
-
         @thor.migration_change_column_type(data)
       end
 
       def add_index_to_column(data)
-        if not data["table_name"].present? \
-          or not data["column"].present?
-          return nil
-        end
-
         @thor.migration_add_index_to_column(data)
       end
 
       def belongs_to(data)
-        if not data["table_name"].present? and data["belongs_to"].present?
-          return nil
-        end
-
         data["column"] = data["belongs_to"].underscore.singularize
         data['column_type'] = "references"
 
         @thor.migration_belongs_to(data)
       end
 
-      # def add_index_to_column_combined(data)
-      #   @thor.migration_add_index_to_column_combined(data)
-      # end
-
       def remove_index_to_column(data)
-        if not data["table_name"].present? \
-          or not data["column"].present?
-          return nil
-        end
-
         @thor.migration_remove_index_to_column(data)
       end
 
-      def create_table(data)
-        if not data["table_name"].present?
-          return nil
-        end
-
-        @thor.migration_create_table(data)
-      end
-
       def drop_table(data)
-        if not data["table_name"].present?
-          return nil
-        end
-
         @thor.migration_drop_table(data)
       end
-
-      def run_migration_or_nil
-        if last_migration_changed?
-          ::Localtower::Tools.perform_cmd('rake db:migrate')
-        else
-          File.delete(last_migration_file)
-          nil
-        end
-      end
-
-      def last_migration_changed?
-        File.readlines(last_migration_file).join != ~ /def change\n  end/
-      end
     end
   end
 end

data/lib/localtower/generators/model.rb

@@ -2,57 +2,78 @@ module Localtower
   module Generators
     class Model
       def initialize(opts)
-        @opts = JSON[opts.to_json]
+        @opts = JSON[opts.to_json] # stringify keys
+        @model_name = @opts['model_name']
+        @attributes = @opts['attributes']
+
+        raise "No model_name provided" if @model_name.blank?
+        raise "No attributes provided" if @attributes.blank?
       end
 
       def run
-        if not @opts['attributes'] or not @opts['model_name'].present?
-          return nil
-        end
-
-        attributes_list = []
-
-        @opts['attributes'].each do |attribute_data|
-          str = "#{attribute_data["attribute_name"]}:#{attribute_data["attribute_type"]}"
-          str << ":index" if attribute_data["index"]
+        attributes_str = parse_attributes.join(" ")
+        cmd = "rails generate model #{model_name.camelize} #{attributes_str}"
 
-          attributes_list << str
-        end
+        ::Localtower::Tools.perform_cmd(cmd)
 
-        attributes_str = attributes_list.join(" ")
-        cmd = "rails g model #{@opts['model_name'].camelize} #{attributes_str}"
+        insert_non_nullable_values
+        insert_default_values
+        insert_array
+        insert_indexes
+      end
 
-        ::Localtower::Tools.perform_cmd(cmd, false)
+      private
 
-        if defaults_present?
-          insert_default_values.call
-        end
+      attr_reader :model_name
+      attr_reader :attributes
 
-        if @opts['run_migrate']
-          ::Localtower::Tools.perform_cmd('rake db:migrate', false)
-          # ::Localtower::Tools.perform_cmd('rake db:migrate RAILS_ENV=test', false)
+      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
+          ].compact.join(':')
         end
-
-        self
       end
 
-      private
+      def insert_array
+        params = attributes
+          .select { |attr| attr['attribute_type'] == 'array' }
+          .map { |attr| attr['attribute_name'] }
 
-      def defaults_present?
-        return false unless @opts['attributes'].any? { |attr| attr["defaults"].present? }
-        true
+        Localtower::Generators::ServiceObjects::InsertArray.new(params).call
       end
 
-      def params_for_defaults
-        @opts['attributes'].each_with_object([]) do |attr, arr|
-          arr << Hash[ attr['attribute_name'], attr['defaults'] ] unless attr['defaults'].empty?
+      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']]
         end
+
+        Localtower::Generators::ServiceObjects::InsertDefaults.new(params).call
       end
 
-      def insert_default_values
-        ::Localtower::Generators::ServiceObjects::InsertDefaults.new(params_for_defaults)
+      def insert_non_nullable_values
+        params = attributes
+          .select { |attr| attr['nullable'] == false }
+          .map{ |attr| attr['attribute_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
+
+        ::Localtower::Generators::ServiceObjects::InsertIndexes.new(params).call
+      end
     end
   end
 end

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

@@ -0,0 +1,23 @@
+module Localtower
+  module Generators
+    module ServiceObjects
+      class InsertArray
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        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)
+          end
+        end
+
+        private
+
+        attr_reader :attributes
+      end
+    end
+  end
+end

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

@@ -2,62 +2,34 @@ module Localtower
   module Generators
     module ServiceObjects
       class InsertDefaults
+        DEFAULTS = {
+          '(no default value)' => '',
+          "empty string ('')" => "''",
+          'zero (0)' => '0',
+          'true' => 'true',
+          'false' => 'false',
+          'empty array ([])' => '[]',
+          'empty hash ({})' => '{}',
+          'nil' => 'nil',
+        }
 
         def initialize(attributes)
           @attributes = attributes
         end
 
         def call
-          insert_defaults
-        end
-
-        private
-
-        attr_reader :attributes
-
-        def insert_defaults
           attributes.each do |attribute|
             attribute.each do |attr_key, attr_value|
-              process_migration_file(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)
             end
           end
-          build_file(file_lines)
-        end
-
-        def process_migration_file(attr_key, attr_value)
-          file_lines.map do |line|
-            attach_default_value(line, attr_key, attr_value)
-          end
-        end
-
-        def attach_default_value(line, attr_key, attr_value)
-          if table_attribute_line?(line) and line.include? attr_key
-            build_line(line, attr_value)
-          else
-            line
-          end
         end
 
-        def build_file(lines)
-          File.open(latest_migration, 'w') { |f| f.puts lines }
-        end
-
-        def build_line(line, attr_value)
-          line.gsub!("\n", "") << ", default: " << "#{attr_value}" << "\n"
-        end
-
-        def latest_migration
-          @latest_migration ||= Dir["#{Rails.root}/db/migrate/*"].last
-        end
-
-        def file_lines
-          @file_lines ||= File.readlines(latest_migration)
-        end
-
-        def table_attribute_line?(line)
-          line.squish.start_with? "t."
-        end
+        private
 
+        attr_reader :attributes
       end
     end
   end

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

@@ -0,0 +1,80 @@
+module Localtower
+  module Generators
+    module ServiceObjects
+      class InsertIndexes
+        USING = [
+          'none',
+          'default',
+          'gin',
+          'gist',
+        ].freeze
+
+        UNIQUE = [
+          false,
+          true,
+        ]
+
+        ALGO = [
+          'default',
+          'concurrently',
+        ]
+
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def call
+          attributes.each do |attribute|
+            attribute.each do |attr_key, options|
+              line_str_original = File.read(Localtower::Tools.last_migration).match(/((.*)add_index :(.*), :#{attr_key})/)[0]
+              line_str = line_str_original.clone
+
+              line_str = inser_using(line_str, options)
+              line_str = inser_unique(line_str, options)
+              line_str = inser_algorithm(line_str, options)
+
+              content = File.read(Localtower::Tools.last_migration).gsub(line_str_original, line_str)
+              content = add_disable_ddl_transaction(content, options)
+
+              File.write(Localtower::Tools.last_migration, content)
+            end
+          end
+        end
+
+        private
+
+        attr_reader :attributes
+
+        def inser_using(line_str, options)
+          return line_str if options['using'] == 'default'
+
+          line_str << ", using: :#{options['using']}"
+        end
+
+        def inser_unique(line_str, options)
+          return line_str if options['unique'] != true
+
+          line_str << ", unique: true"
+        end
+
+        def inser_algorithm(line_str, options)
+          return line_str unless options['algorithm']
+          return line_str if options['algorithm'] == 'default'
+
+          line_str << ", algorithm: :#{options['algorithm']}"
+        end
+
+        def add_disable_ddl_transaction(content, options)
+          return content if options['algorithm'] != 'concurrently'
+
+          # Add disable_ddl_transaction! if the algorythm is 'concurrently'
+          if content['disable_ddl_transaction'].blank?
+            content = content.gsub(/^class (.*)$/, "class \\1\n  disable_ddl_transaction!\n")
+          end
+
+          content
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Localtower
+  module Generators
+    module ServiceObjects
+      class InsertNullable
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def call
+          attributes.each do |attribute|
+            line_str = File.read(Localtower::Tools.last_migration).match(/((.*)t\.(.*)\:#{attribute})/)[0]
+            content = File.read(Localtower::Tools.last_migration).gsub(line_str, "#{line_str}, null: false")
+            File.write(Localtower::Tools.last_migration, content)
+          end
+        end
+
+        private
+
+        attr_reader :attributes
+      end
+    end
+  end
+end