fx 0.1.0 → 0.11.0

data/lib/generators/fx/trigger/templates/db/migrate/create_trigger.erb

@@ -1,4 +1,4 @@
-class <%= migration_class_name %> < ActiveRecord::Migration
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
     create_trigger <%= formatted_name %>, on: <%= formatted_table_name %>
   end

data/lib/generators/fx/trigger/templates/db/migrate/update_trigger.erb

@@ -1,4 +1,4 @@
-class <%= migration_class_name %> < ActiveRecord::Migration
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
     update_trigger <%= formatted_name %>, on: <%= formatted_table_name %>, version: <%= version %>, revert_to_version: <%= previous_version %>
   end

data/lib/generators/fx/trigger/trigger_generator.rb

@@ -1,36 +1,43 @@
 require "rails/generators"
 require "rails/generators/active_record"
+require "generators/fx/version_helper"
+require "generators/fx/migration_helper"
+require "generators/fx/name_helper"
 
 module Fx
   module Generators
     # @api private
     class TriggerGenerator < Rails::Generators::NamedBase
       include Rails::Generators::Migration
+
       source_root File.expand_path("../templates", __FILE__)
       argument :table_name, type: :hash, required: true
 
+      DEFINITION_PATH = %w[db triggers].freeze
+
+      class_option :migration, type: :boolean
+
       def create_triggers_directory
-        unless trigger_definition_path.exist?
-          empty_directory(trigger_definition_path)
-        end
+        return if trigger_definition_path.exist?
+
+        empty_directory(trigger_definition_path)
       end
 
       def create_trigger_definition
-        create_file definition.path
+        create_file(definition.path)
       end
 
       def create_migration_file
-        if updating_existing_trigger?
-          migration_template(
-            "db/migrate/update_trigger.erb",
-            "db/migrate/update_trigger_#{file_name}_to_version_#{version}.rb"
-          )
-        else
-          migration_template(
-            "db/migrate/create_trigger.erb",
-            "db/migrate/create_trigger_#{file_name}.rb"
-          )
-        end
+        return if migration_helper.skip_creation?
+
+        template_info = migration_helper.migration_template_info(
+          object_type: :trigger,
+          file_name: file_name,
+          updating_existing: version_helper.updating_existing?,
+          version: version_helper.current_version
+        )
+
+        migration_template(template_info[:template], template_info[:filename])
       end
 
       def self.next_migration_number(dir)
@@ -39,69 +46,57 @@ module Fx
 
       no_tasks do
         def previous_version
-          @_previous_version ||= Dir.entries(trigger_definition_path).
-            map { |name| version_regex.match(name).try(:[], "version").to_i }.
-            max
+          version_helper.previous_version
         end
 
         def version
-          @_version ||= previous_version.next
+          version_helper.current_version
         end
 
         def migration_class_name
-          if updating_existing_trigger?
-            "UpdateTrigger#{class_name}ToVersion#{version}"
+          if version_helper.updating_existing?
+            migration_helper.update_migration_class_name(
+              object_type: :trigger,
+              class_name: class_name,
+              version: version
+            )
           else
             super
           end
         end
 
         def formatted_name
-          if singular_name.include?(".")
-            "\"#{singular_name}\""
-          else
-            ":#{singular_name}"
-          end
+          Fx::Generators::NameHelper.format_for_migration(singular_name)
         end
 
         def formatted_table_name
-          name = table_name["table_name"] || table_name["on"]
-
-          if name.nil?
-            raise(
-              ArgumentError,
-              "Either `table_name:NAME` or `on:NAME` must be specified",
-            )
-          end
-
-          if name.include?(".")
-            "\"#{name}\""
-          else
-            ":#{name}"
-          end
+          Fx::Generators::NameHelper.format_table_name_from_hash(table_name)
         end
       end
 
       private
 
-      def version_regex
-        /\A#{file_name}_v(?<version>\d+)\.sql\z/
+      def trigger_definition_path
+        @_trigger_definition_path ||= Rails.root.join(*DEFINITION_PATH)
       end
 
-      def updating_existing_trigger?
-        previous_version > 0
+      def version_helper
+        @_version_helper ||= Fx::Generators::VersionHelper.new(
+          file_name: file_name,
+          definition_path: trigger_definition_path
+        )
+      end
+
+      def migration_helper
+        @_migration_helper ||= Fx::Generators::MigrationHelper.new(options)
       end
 
       def definition
-        Fx::Definition.new(
-          name: file_name,
-          version: version,
-          type: "trigger",
-        )
+        version_helper.definition_for_version(version: version, type: :trigger)
       end
 
-      def trigger_definition_path
-        @_trigger_definition_path ||= Rails.root.join(*["db", "triggers"])
+      def updating_existing_trigger?
+        version_helper.updating_existing?
       end
     end
   end

data/lib/generators/fx/version_helper.rb

@@ -0,0 +1,55 @@
+module Fx
+  module Generators
+    # @api private
+    class VersionHelper
+      def initialize(file_name:, definition_path:)
+        @file_name = file_name
+        @definition_path = definition_path
+      end
+
+      def previous_version
+        @previous_version ||= existing_versions.max || 0
+      end
+
+      def current_version
+        previous_version.next
+      end
+
+      def updating_existing?
+        previous_version > 0
+      end
+
+      def creating_new?
+        previous_version == 0
+      end
+
+      def definition_for_version(version:, type:)
+        case type
+        when :function
+          Fx::Definition.function(name: file_name, version: version)
+        when :trigger
+          Fx::Definition.trigger(name: file_name, version: version)
+        else
+          raise(
+            ArgumentError,
+            "Unknown type: #{type}. Must be :function or :trigger"
+          )
+        end
+      end
+
+      private
+
+      VERSION_PATTERN = /v(\d+)/
+      private_constant :VERSION_PATTERN
+
+      attr_reader :file_name, :definition_path
+
+      def existing_versions
+        Dir
+          .glob("#{file_name}_v*.sql", base: definition_path)
+          .map { |file| file[VERSION_PATTERN, 1].to_i }
+          .compact
+      end
+    end
+  end
+end

data/spec/acceptance/user_manages_functions_spec.rb

@@ -1,16 +1,16 @@
 require "acceptance_helper"
 
-describe "User manages functions" do
+RSpec.describe "User manages functions" do
   it "handles simple functions" do
     successfully "rails generate fx:function test"
-    write_function_definition "test_v01", <<~EOS
+    write_function_definition "test_v01", <<~SQL
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
           RETURN 'test';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     successfully "rake db:migrate"
 
     result = execute("SELECT * FROM test() AS result")
@@ -19,19 +19,39 @@ describe "User manages functions" do
     successfully "rails generate fx:function test"
     verify_identical_definitions(
       "db/functions/test_v01.sql",
-      "db/functions/test_v02.sql",
+      "db/functions/test_v02.sql"
     )
-    write_function_definition "test_v02", <<~EOS
+    write_function_definition "test_v02", <<~SQL
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
           RETURN 'testest';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     successfully "rake db:migrate"
 
     result = execute("SELECT * FROM test() AS result")
     expect(result).to eq("result" => "testest")
   end
+
+  it "handles functions with arguments" do
+    successfully "rails generate fx:function adder"
+    write_function_definition "adder_v01", <<~SQL
+      CREATE FUNCTION adder(x int, y int)
+      RETURNS int AS $$
+      BEGIN
+          RETURN $1 + $2;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    successfully "rake db:migrate"
+
+    result = execute("SELECT * FROM adder(1, 2) AS result")
+    result["result"] = result["result"].to_i
+    expect(result).to eq("result" => 3)
+
+    successfully "rails destroy fx:function adder"
+    successfully "rake db:migrate"
+  end
 end

data/spec/acceptance/user_manages_triggers_spec.rb

@@ -1,10 +1,10 @@
 require "acceptance_helper"
 
-describe "User manages triggers" do
+RSpec.describe "User manages triggers" do
   it "handles simple triggers" do
     successfully "rails generate model user name:string upper_name:string"
     successfully "rails generate fx:function uppercase_users_name"
-    write_function_definition "uppercase_users_name_v01", <<~EOS
+    write_function_definition "uppercase_users_name_v01", <<~SQL
       CREATE OR REPLACE FUNCTION uppercase_users_name()
       RETURNS trigger AS $$
       BEGIN
@@ -12,14 +12,14 @@ describe "User manages triggers" do
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     successfully "rails generate fx:trigger uppercase_users_name table_name:users"
-    write_trigger_definition "uppercase_users_name_v01", <<~EOS
+    write_trigger_definition "uppercase_users_name_v01", <<~SQL
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
-    EOS
+          EXECUTE FUNCTION uppercase_users_name();
+    SQL
     successfully "rake db:migrate"
 
     execute <<~SQL
@@ -32,18 +32,18 @@ describe "User manages triggers" do
     expect(result).to eq("upper_name" => "BOB")
 
     successfully "rails generate fx:trigger uppercase_users_name table_name:users"
-    write_trigger_definition "uppercase_users_name_v02", <<~EOS
+    write_trigger_definition "uppercase_users_name_v02", <<~SQL
       CREATE TRIGGER uppercase_users_name
           BEFORE UPDATE ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
-    EOS
+          EXECUTE FUNCTION uppercase_users_name();
+    SQL
     successfully "rake db:migrate"
-    execute <<~EOS
+    execute <<~SQL
       UPDATE users
       SET name = 'Alice'
       WHERE id = 1;
-    EOS
+    SQL
 
     result = execute("SELECT upper_name FROM users WHERE name = 'Alice';")
     expect(result).to eq("upper_name" => "ALICE")

data/spec/acceptance_helper.rb

@@ -5,29 +5,35 @@ ENV["RAILS_ENV"] = "test"
 RSpec.configure do |config|
   config.around(:each) do |example|
     Dir.chdir("spec/dummy") do
+      DatabaseReset.call
+
       example.run
+
+      DatabaseReset.call
     end
   end
 
   config.before(:suite) do
     Dir.chdir("spec/dummy") do
-      system <<-CMD
-        git init 1>/dev/null &&
-        git add -A &&
-        git commit --no-gpg-sign --message 'initial' 1>/dev/null
-      CMD
+      system [
+        "git init -b master 1>/dev/null",
+        "git config user.email 'fx@example.com'",
+        "git config user.name 'Fx'",
+        "git add -A",
+        "git commit --no-gpg-sign --message 'initial' 1>/dev/null"
+      ].join(" && ")
     end
   end
 
   config.after(:suite) do
     Dir.chdir("spec/dummy") do
       ActiveRecord::Base.connection.disconnect!
-      system <<-CMD
-        rake db:drop db:create &&
-        git add -A &&
-        git reset --hard HEAD 1>/dev/null &&
-        rm -rf .git/ 1>/dev/null
-      CMD
+      DatabaseReset.call
+      system [
+        "git add -A",
+        "git reset --hard HEAD 1>/dev/null",
+        "rm -rf .git/ 1>/dev/null"
+      ].join(" && ")
     end
   end
 

data/spec/dummy/Rakefile

@@ -1,6 +1,13 @@
 # Add your own tasks in files placed in lib/tasks ending in .rake,
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
 
-require File.expand_path('../config/application', __FILE__)
+require File.expand_path("../config/application", __FILE__)
 
 Rails.application.load_tasks
+
+unless Rake::Task.task_defined?("db:environment:set")
+  desc "dummy task for rails versions where this task does not exist"
+  task "db:environment:set" do
+    # no-op
+  end
+end

data/spec/dummy/bin/bundle

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
-load Gem.bin_path('bundler', 'bundle')
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
+load Gem.bin_path("bundler", "bundle")

data/spec/dummy/bin/rails

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require_relative '../config/boot'
-require 'rails/commands'
+APP_PATH = File.expand_path("../../config/application", __FILE__)
+require_relative "../config/boot"
+require "rails/commands"

data/spec/dummy/bin/rake

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-require_relative '../config/boot'
-require 'rake'
+require_relative "../config/boot"
+require "rake"
 Rake.application.run

data/spec/dummy/config/application.rb

@@ -11,5 +11,7 @@ module Dummy
     config.cache_classes = true
     config.eager_load = false
     config.active_support.deprecation = :stderr
+
+    config.load_defaults 7.2
   end
 end

data/spec/dummy/config/database.yml

@@ -1,5 +1,7 @@
 development: &default
   adapter: postgresql
+  host: 127.0.0.1
+  user: <%= ENV['POSTGRES_USER'] %>
   database: dummy_development
   encoding: unicode
   pool: 5

data/spec/dummy/config.ru

@@ -1,4 +1,4 @@
 # This file is used by Rack-based servers to start the application.
 
-require ::File.expand_path('../config/environment',  __FILE__)
+require ::File.expand_path("../config/environment", __FILE__)
 run Rails.application

data/spec/features/functions/migrations_spec.rb

@@ -1,22 +1,22 @@
 require "spec_helper"
 
-describe "Function migrations", :db do
+RSpec.describe "Function migrations", :db do
   around do |example|
-    sql_definition = <<~EOS
+    sql_definition = <<~SQL
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
           RETURN 'test';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     with_function_definition(name: :test, sql_definition: sql_definition) do
       example.run
     end
   end
 
   it "can run migrations that create functions" do
-    migration = Class.new(ActiveRecord::Migration) do
+    migration = Class.new(migration_class) do
       def up
         create_function :test
       end
@@ -28,7 +28,7 @@ describe "Function migrations", :db do
   it "can run migrations that drop functions" do
     connection.create_function(:test)
 
-    migration = Class.new(ActiveRecord::Migration) do
+    migration = Class.new(migration_class) do
       def up
         drop_function :test
       end
@@ -40,20 +40,20 @@ describe "Function migrations", :db do
   it "can run migrations that updates functions" do
     connection.create_function(:test)
 
-    sql_definition = <<~EOS
+    sql_definition = <<~SQL
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
           RETURN 'testest';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     with_function_definition(
       name: :test,
       version: 2,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
-      migration = Class.new(ActiveRecord::Migration) do
+      migration = Class.new(migration_class) do
         def change
           update_function :test, version: 2, revert_to_version: 1
         end

data/spec/features/functions/revert_spec.rb

@@ -1,22 +1,22 @@
 require "spec_helper"
 
-describe "Reverting migrations", :db do
+RSpec.describe "Reverting migrations", :db do
   around do |example|
-    sql_definition = <<~EOS
+    sql_definition = <<~SQL
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
           RETURN 'test';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     with_function_definition(name: :test, sql_definition: sql_definition) do
       example.run
     end
   end
 
   it "can run reversible migrations for creating functions" do
-    migration = Class.new(ActiveRecord::Migration) do
+    migration = Class.new(migration_class) do
       def change
         create_function :test
       end
@@ -28,42 +28,42 @@ describe "Reverting migrations", :db do
   it "can run reversible migrations for dropping functions" do
     connection.create_function(:test)
 
-    good_migration = Class.new(ActiveRecord::Migration) do
+    good_migration = Class.new(migration_class) do
       def change
         drop_function :test, revert_to_version: 1
       end
     end
-    bad_migration = Class.new(ActiveRecord::Migration) do
+    bad_migration = Class.new(migration_class) do
       def change
         drop_function :test
       end
     end
 
     expect { run_migration(good_migration, [:up, :down]) }.not_to raise_error
-    expect { run_migration(bad_migration, [:up, :down]) }.
-      to raise_error(
+    expect { run_migration(bad_migration, [:up, :down]) }
+      .to raise_error(
         ActiveRecord::IrreversibleMigration,
-        /`create_function` is reversible only if given a `revert_to_version`/,
+        /`create_function` is reversible only if given a `revert_to_version`/
       )
   end
 
   it "can run reversible migrations for updating functions" do
     connection.create_function(:test)
 
-    sql_definition = <<~EOS
+    sql_definition = <<~SQL
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
         RETURN 'bar';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     with_function_definition(
       name: :test,
       version: 2,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
-      migration = Class.new(ActiveRecord::Migration) do
+      migration = Class.new(migration_class) do
         def change
           update_function :test, version: 2, revert_to_version: 1
         end

data/spec/features/triggers/migrations_spec.rb

@@ -1,15 +1,15 @@
 require "spec_helper"
 
-describe "Trigger migrations", :db do
+RSpec.describe "Trigger migrations", :db do
   around do |example|
-    connection.execute <<~EOS
+    connection.execute <<~SQL
       CREATE TABLE users (
           id int PRIMARY KEY,
           name varchar(256),
           upper_name varchar(256)
       );
-    EOS
-    Fx.database.create_function <<~EOS
+    SQL
+    Fx.database.create_function <<~SQL
       CREATE OR REPLACE FUNCTION uppercase_users_name()
       RETURNS trigger AS $$
       BEGIN
@@ -17,23 +17,23 @@ describe "Trigger migrations", :db do
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-    EOS
-    sql_definition = <<~EOS
+    SQL
+    sql_definition = <<~SQL
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
-    EOS
+          EXECUTE FUNCTION uppercase_users_name();
+    SQL
     with_trigger_definition(
       name: :uppercase_users_name,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
       example.run
     end
   end
 
   it "can run migrations that create triggers" do
-    migration = Class.new(ActiveRecord::Migration) do
+    migration = Class.new(migration_class) do
       def up
         create_trigger :uppercase_users_name
       end
@@ -45,7 +45,7 @@ describe "Trigger migrations", :db do
   it "can run migrations that drop triggers" do
     connection.create_trigger(:uppercase_users_name)
 
-    migration = Class.new(ActiveRecord::Migration) do
+    migration = Class.new(migration_class) do
       def up
         drop_trigger :uppercase_users_name, on: :users
       end