localtower 0.5.0 → 2.0.0

data/app/views/localtower/pages/new_model.html.erb

@@ -0,0 +1,21 @@
+<% content_for :title do %>New Model<% end %>
+<div>
+  <%= form_tag models_path, class: "" do %>
+    <div class="flex flex-col gap-2">
+      <div class="block text-localtower-100">Model name <span class="text-localtower-400">(required)</span></div>
+      <div class="w-80">
+        <input autocomplete="off" type="text" data-selector="modelName" name="model[model_name]" class="px-2 py-1.5 rounded bg-localtower-600 border border-localtower-500 inline-block w-full outline-none focus:border-localtower-400 transition-colors text-localtower-100 placeholder:italic placeholder:text-localtower-450 focus:placeholder:text-localtower-600" placeholder="Ex: User" required>
+      </div>
+      <input type="hidden" id="form_attributes" name="model[attributes]">
+    </div>
+    <div class="py-4 flex flex-col gap-2">
+      <label class="block text-localtower-100">Columns</label>
+      <div id="react-container-new-model"></div>
+    </div>
+    <div>
+      <button type="submit" value="true" class="px-3 py-1.5 rounded-md bg-green-800 text-localtower-100 border border-green-700 inline-block outline-none hover:border-green-500 hover:bg-green-700 hover:text-white active:opacity-60 transition-colors text-md">
+        Generate Model
+      </button>
+    </div>
+  <% end %>
+</div>

data/config/routes.rb

@@ -1,13 +1,13 @@
 Localtower::Engine.routes.draw do
+  get 'migrations/new', to: 'pages#new_migration', as: :new_migration
   get 'migrations', to: 'pages#migrations', as: :migrations
   post 'migrations', to: 'pages#post_migrations'
 
-  get 'models', to: 'pages#models', as: :models
+  get 'models/new', to: 'pages#new_model', as: :new_model
   post 'models', to: 'pages#post_models'
 
-  # get ':v/:asset', to: 'pages#asset_render', as: 'asset_render', :constraints => { :v => /[^\/]*/, :asset => /[^\/]*/ }
-  get 'schema', to: 'pages#schema', as: 'schema'
-  post 'actions', to: 'pages#post_actions', as: 'actions'
+  post 'actions', to: 'pages#post_actions', as: :actions
+  post 'rm_file', to: 'pages#rm_file', as: :rm_file
 
-  root :to => redirect('models')
+  root :to => redirect('models/new')
 end

data/lib/localtower/engine.rb

@@ -2,8 +2,11 @@ module Localtower
   class Engine < ::Rails::Engine
     isolate_namespace Localtower
 
-    initializer 'static assets' do |app|
-      app.middleware.use ::ActionDispatch::Static, "#{root}/public"
+    initializer 'localtower.add_static_assets', before: :build_middleware_stack do |app|
+      app.config.middleware.use Rack::Deflater
+      app.config.middleware.use ::ActionDispatch::Static, "#{root}/public"
+      # Later: have a better assets pipeline to be able to version and cache assets forever
+      # app.config.middleware.use ::ActionDispatch::Static, "#{root}/public", headers: { "Cache-Control" => "public, max-age=31536000" }
     end
   end
 end

data/lib/localtower/generators/migration.rb

@@ -1,120 +1,115 @@
+#
+# @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
-        # data = {last_migration_file: "", column_type: "", table_name: "", column: "", nullable: true, index: true}
         def migration_add_column(data)
-          file = data["last_migration_file"]
+          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']}, :text"
-            line << ", default: []"
+          if %w[array].include?(data["column_type"])
+            line  = "#{SPACE_PADDING}add_column :#{data['table_name']}, :#{data['column_name']}, :string"
+            line << ", default: #{data['default']}" if data['default'].present?
             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  = "#{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 not data['nullable']
-            line << ", index: true" if data['index'] == true
+            line << ", null: false" if data['nullable'] == false
           end
 
           line << "\n"
 
           inject_in_migration(file, line)
+
+          if data["index"].present?
+            migration_add_index_to_column(data)
+          end
         end
 
         def migration_remove_column(data)
-          file = data['last_migration_file']
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No attribute name provided" if data['column_name'].blank?
 
-          line = "    remove_column :#{data['table_name']}, :#{data['column']}\n"
+          line = "#{SPACE_PADDING}remove_column :#{data['table_name']}, :#{data['column_name']}\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_rename_column(data)
-          file = data['last_migration_file']
+          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 = "    rename_column :#{data['table_name']}, :#{data['column']}, :#{data['new_column_name']}\n"
+          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)
-          file = data['last_migration_file']
+          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 = "    change_column :#{data['table_name']}, :#{data['column']}, :#{data['new_column_type']}\n"
+          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)
-          file = data['last_migration_file']
+          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 = "    add_index :#{data["table_name"]}, :#{data["column"]}\n"
+          line = "#{SPACE_PADDING}add_index :#{data['table_name']}, :#{data['column_name']}\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["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)
-          file = data["last_migration_file"]
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No index_name provided" if data['index_name'].blank?
 
-          line = "    remove_index :#{data["table_name"]}, :#{data["column"]}\n"
+          line = "#{SPACE_PADDING}remove_index :#{data['table_name']}, name: :#{data['index_name']}\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"
-
-          inject_in_migration(file, line)
+          raise "No table name provided" if data['table_name'].blank?
+          raise "No attribute name provided" if data['column_name'].blank?
 
-          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']}"
 
-          ::Localtower::Tools::ThorTools.new.insert_after_word(file, after, line1)
-
-
-          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"
-
-          ::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"
+          line << ", foreign_key: true" if data['foreign_key'].present?
+          line << ", index: true"
+          line << "\n"
 
           inject_in_migration(file, line)
         end
 
         def migration_drop_table(data)
-          file = data["last_migration_file"]
+          raise "No table name provided" if data['table_name'].blank?
 
-          line = "    drop_table :#{data["table_name"]}, force: :cascade\n"
+          line = "#{SPACE_PADDING}drop_table :#{data['table_name']}\n"
 
           inject_in_migration(file, line)
         end
@@ -122,133 +117,196 @@ 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_pending
         end
       end
     end
 
     class Migration
-      TYPES = %w(string datetime text uuid integer float json jsonb decimal binary boolean array references).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 = [
-        'add_column',
-        'remove_column',
-        'rename_column',
-        'change_column_type',
-        'add_index_to_column',
-        'belongs_to',
-        'remove_index_to_column',
-        'drop_table',
-      ].freeze
-
-      DEFAULTS = [
-        "true", "false", "nil", "0"
+        {
+          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(opts)
+      def initialize(migrations, migration_name = nil)
         @thor = ThorGeneratorMigration.new
-        @opts = JSON[opts.to_json]
-      end
 
-      # @opts['migrations'] = []
-      # @opts['run_migrate'] = true
-      def run
-        model_names = @opts['migrations'].map { |line| line['table_name'].camelize }.join
-
-        cmd = "Change#{model_names}#{@opts['migration_name']}At#{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
-
-          {
-            '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) },
-            'create_table' => -> { create_table(action_line) },
-            'drop_table' => -> { drop_table(action_line) }
-            }[action_line['action'].downcase].call
-        end
-
-        if @opts['run_migrate']
-          run_migration_or_nil
-        end
+        # stringify keys:
+        @migrations = JSON[migrations.to_json]
+        @migration_name = migration_name
       end
 
-      #====================================
-      def last_migration_file
-        Dir["#{Rails.root}/db/migrate/*"].sort.last
-      end
-
-      # VALIDATION before continuing:
-      private
+      # 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 add_column(data)
-        @thor.migration_add_column(data)
-      end
-
-      def remove_column(data)
-        @thor.migration_remove_column(data)
-      end
-
-      def rename_column(data)
-        @thor.migration_rename_column(data)
-      end
-
-      def change_column_type(data)
-        @thor.migration_change_column_type(data)
-      end
+      def run
+        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
 
-      def add_index_to_column(data)
-        @thor.migration_add_index_to_column(data)
-      end
+            "#{action_names}#{column_names}For#{model_names}"
+          end
 
-      def belongs_to(data)
-        data["column"] = data["belongs_to"].underscore.singularize
-        data['column_type'] = "references"
+          ::Localtower::Tools.perform_migration(migration_name_final)
+        end
 
-        @thor.migration_belongs_to(data)
-      end
+        migrations.each do |action_line|
+          next if action_line['action_name'].blank?
 
-      def remove_index_to_column(data)
-        @thor.migration_remove_index_to_column(data)
-      end
+          # action_line['table_name'] = action_line['model_name'].pluralize.underscore
 
-      def create_table(data)
-        @thor.migration_create_table(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 drop_table(data)
-        @thor.migration_drop_table(data)
-      end
+          raise "No proc found for action_name #{action_line['action_name']}" unless proc_var
 
-      def run_migration_or_nil
-        if last_migration_changed?
-          ::Localtower::Tools.perform_cmd('rake db:migrate')
-        else
-          File.delete(last_migration_file)
-          nil
+          proc_var.call
         end
       end
 
-      def last_migration_changed?
-        File.readlines(last_migration_file).join != ~ /def change\n  end/
-      end
+      attr_reader :thor, :migrations
     end
   end
 end

data/lib/localtower/generators/model.rb

@@ -3,52 +3,85 @@ module Localtower
     class Model
       def initialize(opts)
         @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
 
-      # data = {attributes: "", model_name: ""}
       def run
-        return nil if @opts['attributes'].blank?
-        return nil if @opts['model_name'].blank?
+        attributes_str = parse_attributes.join(" ")
+        cmd = "rails generate model #{model_name.camelize} #{attributes_str} --force"
+        ::Localtower::Tools.perform_cmd(cmd)
 
-        attributes_list = []
+        insert_non_nullable_values
+        insert_default_values
+        insert_array
+        insert_indexes
+        insert_foreign_keys
+      end
 
-        @opts['attributes'].each do |attribute_data|
-          str = "#{attribute_data["attribute_name"]}:#{attribute_data["attribute_type"]}"
-          str << ":index" if attribute_data["index"]
+      private
 
-          attributes_list << str
-        end
+      attr_reader :model_name, :attributes
 
-        attributes_str = attributes_list.join(" ")
-        cmd = "rails g model #{@opts['model_name'].camelize} #{attributes_str}"
+      def parse_attributes
+        attributes.map do |attr_hash|
+          [
+            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
 
-        ::Localtower::Tools.perform_cmd(cmd, false)
+      def insert_array
+        params = attributes
+                 .select { |attr| attr['column_type'] == 'array' }
+                 .map { |attr| attr['column_name'] }
 
-        if defaults_present?
-          insert_default_values.call
-        end
+        Localtower::Generators::ServiceObjects::InsertArray.new(params).call
+      end
 
-        if @opts['run_migrate']
-          ::Localtower::Tools.perform_cmd('rake db:migrate', false)
+      def insert_default_values
+        params = attributes
+                 .select { |attr| attr['default'].present? }
+                 .each_with_object([]) do |attr, arr|
+          arr << Hash[attr['column_name'], attr['default']]
         end
 
-        self
+        Localtower::Generators::ServiceObjects::InsertDefaults.new(params).call
       end
 
-      private
+      def insert_non_nullable_values
+        params = attributes
+                 .select { |attr| attr['nullable'] == false }
+                 .map { |attr| attr['column_name'] }
 
-      def defaults_present?
-        @opts['attributes'].any? { |attr| attr["defaults"].present? }
+        ::Localtower::Generators::ServiceObjects::InsertNullable.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_indexes
+        params = attributes
+                 .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_default_values
-        ::Localtower::Generators::ServiceObjects::InsertDefaults.new(params_for_defaults)
+      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