fx 0.1.0

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

@@ -0,0 +1,5 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def change
+    update_trigger <%= formatted_name %>, on: <%= formatted_table_name %>, version: <%= version %>, revert_to_version: <%= previous_version %>
+  end
+end

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

@@ -0,0 +1,108 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+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
+
+      def create_triggers_directory
+        unless trigger_definition_path.exist?
+          empty_directory(trigger_definition_path)
+        end
+      end
+
+      def create_trigger_definition
+        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
+      end
+
+      def self.next_migration_number(dir)
+        ::ActiveRecord::Generators::Base.next_migration_number(dir)
+      end
+
+      no_tasks do
+        def previous_version
+          @_previous_version ||= Dir.entries(trigger_definition_path).
+            map { |name| version_regex.match(name).try(:[], "version").to_i }.
+            max
+        end
+
+        def version
+          @_version ||= previous_version.next
+        end
+
+        def migration_class_name
+          if updating_existing_trigger?
+            "UpdateTrigger#{class_name}ToVersion#{version}"
+          else
+            super
+          end
+        end
+
+        def formatted_name
+          if singular_name.include?(".")
+            "\"#{singular_name}\""
+          else
+            ":#{singular_name}"
+          end
+        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
+        end
+      end
+
+      private
+
+      def version_regex
+        /\A#{file_name}_v(?<version>\d+)\.sql\z/
+      end
+
+      def updating_existing_trigger?
+        previous_version > 0
+      end
+
+      def definition
+        Fx::Definition.new(
+          name: file_name,
+          version: version,
+          type: "trigger",
+        )
+      end
+
+      def trigger_definition_path
+        @_trigger_definition_path ||= Rails.root.join(*["db", "triggers"])
+      end
+    end
+  end
+end

data/spec/acceptance/user_manages_functions_spec.rb

@@ -0,0 +1,37 @@
+require "acceptance_helper"
+
+describe "User manages functions" do
+  it "handles simple functions" do
+    successfully "rails generate fx:function test"
+    write_function_definition "test_v01", <<~EOS
+      CREATE OR REPLACE FUNCTION test()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    successfully "rake db:migrate"
+
+    result = execute("SELECT * FROM test() AS result")
+    expect(result).to eq("result" => "test")
+
+    successfully "rails generate fx:function test"
+    verify_identical_definitions(
+      "db/functions/test_v01.sql",
+      "db/functions/test_v02.sql",
+    )
+    write_function_definition "test_v02", <<~EOS
+      CREATE OR REPLACE FUNCTION test()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'testest';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    successfully "rake db:migrate"
+
+    result = execute("SELECT * FROM test() AS result")
+    expect(result).to eq("result" => "testest")
+  end
+end

data/spec/acceptance/user_manages_triggers_spec.rb

@@ -0,0 +1,51 @@
+require "acceptance_helper"
+
+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
+      CREATE OR REPLACE FUNCTION uppercase_users_name()
+      RETURNS trigger AS $$
+      BEGIN
+        NEW.upper_name = UPPER(NEW.name);
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    successfully "rails generate fx:trigger uppercase_users_name table_name:users"
+    write_trigger_definition "uppercase_users_name_v01", <<~EOS
+      CREATE TRIGGER uppercase_users_name
+          BEFORE INSERT ON users
+          FOR EACH ROW
+          EXECUTE PROCEDURE uppercase_users_name();
+    EOS
+    successfully "rake db:migrate"
+
+    execute <<~SQL
+      INSERT INTO users
+      (name, created_at, updated_at)
+      VALUES
+      ('Bob', NOW(), NOW());
+    SQL
+    result = execute("SELECT upper_name FROM users WHERE name = 'Bob';")
+    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
+      CREATE TRIGGER uppercase_users_name
+          BEFORE UPDATE ON users
+          FOR EACH ROW
+          EXECUTE PROCEDURE uppercase_users_name();
+    EOS
+    successfully "rake db:migrate"
+    execute <<~EOS
+      UPDATE users
+      SET name = 'Alice'
+      WHERE id = 1;
+    EOS
+
+    result = execute("SELECT upper_name FROM users WHERE name = 'Alice';")
+    expect(result).to eq("upper_name" => "ALICE")
+  end
+end

data/spec/acceptance_helper.rb

@@ -0,0 +1,61 @@
+require "bundler"
+
+ENV["RAILS_ENV"] = "test"
+
+RSpec.configure do |config|
+  config.around(:each) do |example|
+    Dir.chdir("spec/dummy") do
+      example.run
+    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
+    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
+    end
+  end
+
+  def successfully(command)
+    `RAILS_ENV=test #{command}`
+    expect($?.exitstatus).to eq(0), "'#{command}' was unsuccessful"
+  end
+
+  def write_function_definition(file, contents)
+    write_definition(file, contents, "functions")
+  end
+
+  def write_trigger_definition(file, contents)
+    write_definition(file, contents, "triggers")
+  end
+
+  def write_definition(file, contents, directory)
+    File.open("db/#{directory}/#{file}.sql", File::WRONLY) do |definition|
+      definition.truncate(0)
+      definition.write(contents)
+    end
+  end
+
+  def verify_identical_definitions(def_a, def_b)
+    successfully "cmp #{def_a} #{def_b}"
+  end
+
+  def execute(command)
+    ActiveRecord::Base.connection.execute(command).first
+  end
+end

data/spec/dummy/.gitignore

@@ -0,0 +1,16 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# 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__)
+
+Rails.application.load_tasks

data/spec/dummy/bin/bundle

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

data/spec/dummy/bin/rails

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

data/spec/dummy/bin/rake

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

data/spec/dummy/config.ru

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

data/spec/dummy/config/application.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../boot", __FILE__)
+
+# Pick the frameworks you want:
+require "active_record/railtie"
+
+Bundler.require(*Rails.groups)
+require "fx"
+
+module Dummy
+  class Application < Rails::Application
+    config.cache_classes = true
+    config.eager_load = false
+    config.active_support.deprecation = :stderr
+  end
+end

data/spec/dummy/config/boot.rb

@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../../Gemfile", __FILE__)
+
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)

data/spec/dummy/config/database.yml

@@ -0,0 +1,9 @@
+development: &default
+  adapter: postgresql
+  database: dummy_development
+  encoding: unicode
+  pool: 5
+
+test:
+  <<: *default
+  database: dummy_test

data/spec/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the Rails application.
+require File.expand_path("../application", __FILE__)
+
+# Initialize the Rails application.
+Rails.application.initialize!

data/spec/features/functions/migrations_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe "Function migrations", :db do
+  around do |example|
+    sql_definition = <<~EOS
+      CREATE OR REPLACE FUNCTION test()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    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
+      def up
+        create_function :test
+      end
+    end
+
+    expect { run_migration(migration, :up) }.not_to raise_error
+  end
+
+  it "can run migrations that drop functions" do
+    connection.create_function(:test)
+
+    migration = Class.new(ActiveRecord::Migration) do
+      def up
+        drop_function :test
+      end
+    end
+
+    expect { run_migration(migration, :up) }.not_to raise_error
+  end
+
+  it "can run migrations that updates functions" do
+    connection.create_function(:test)
+
+    sql_definition = <<~EOS
+      CREATE OR REPLACE FUNCTION test()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'testest';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    with_function_definition(
+      name: :test,
+      version: 2,
+      sql_definition: sql_definition,
+    ) do
+      migration = Class.new(ActiveRecord::Migration) do
+        def change
+          update_function :test, version: 2, revert_to_version: 1
+        end
+      end
+
+      expect { run_migration(migration, :change) }.not_to raise_error
+    end
+  end
+end

data/spec/features/functions/revert_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe "Reverting migrations", :db do
+  around do |example|
+    sql_definition = <<~EOS
+      CREATE OR REPLACE FUNCTION test()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    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
+      def change
+        create_function :test
+      end
+    end
+
+    expect { run_migration(migration, [:up, :down]) }.not_to raise_error
+  end
+
+  it "can run reversible migrations for dropping functions" do
+    connection.create_function(:test)
+
+    good_migration = Class.new(ActiveRecord::Migration) do
+      def change
+        drop_function :test, revert_to_version: 1
+      end
+    end
+    bad_migration = Class.new(ActiveRecord::Migration) 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(
+        ActiveRecord::IrreversibleMigration,
+        /`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
+      CREATE OR REPLACE FUNCTION test()
+      RETURNS text AS $$
+      BEGIN
+        RETURN 'bar';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    with_function_definition(
+      name: :test,
+      version: 2,
+      sql_definition: sql_definition,
+    ) do
+      migration = Class.new(ActiveRecord::Migration) do
+        def change
+          update_function :test, version: 2, revert_to_version: 1
+        end
+      end
+
+      expect { run_migration(migration, [:up, :down]) }.not_to raise_error
+    end
+  end
+end