fx 0.3.0 → 0.6.1

data/lib/fx/schema_dumper/function.rb

@@ -5,15 +5,24 @@ module Fx
     # @api private
     module Function
       def tables(stream)
+        if Fx.configuration.dump_functions_at_beginning_of_schema
+          functions(stream)
+          empty_line(stream)
+        end
+
         super
-        functions(stream)
-      end
 
-      def functions(stream)
-        if dumpable_functions_in_database.any?
-          stream.puts
+        unless Fx.configuration.dump_functions_at_beginning_of_schema
+          functions(stream)
+          empty_line(stream)
         end
+      end
+
+      def empty_line(stream)
+        stream.puts if dumpable_functions_in_database.any?
+      end
 
+      def functions(stream)
         dumpable_functions_in_database.each do |function|
           stream.puts(function.to_schema)
         end

data/lib/fx/statements.rb

@@ -9,8 +9,3 @@ module Fx
     include Trigger
   end
 end
-
-ActiveRecord::ConnectionAdapters::AbstractAdapter.send(
-  :include,
-  Fx::Statements,
-)

data/lib/fx/statements/function.rb

@@ -36,6 +36,7 @@ module Fx
             "version or sql_definition must be specified",
           )
         end
+        sql_definition = sql_definition.strip_heredoc if sql_definition
         sql_definition ||= Fx::Definition.new(name: name, version: version).to_sql
 
         Fx.database.create_function(sql_definition)
@@ -49,8 +50,8 @@ module Fx
       #   the `version` argument to {#create_function}.
       # @return The database response from executing the drop statement.
       #
-      # @example Drop a function, rolling back to version 3 on rollback
-      #   drop_function(:uppercase_users_name, on: :users, revert_to_version: 3)
+      # @example Drop a function, rolling back to version 2 on rollback
+      #   drop_function(:uppercase_users_name, revert_to_version: 2)
       #
       def drop_function(name, revert_to_version: nil)
         Fx.database.drop_function(name)
@@ -93,6 +94,7 @@ module Fx
           )
         end
 
+        sql_definition = sql_definition.strip_heredoc if sql_definition
         sql_definition ||= Fx::Definition.new(
           name: name,
           version: version,

data/lib/fx/statements/trigger.rb

@@ -39,6 +39,7 @@ module Fx
           version = 1
         end
 
+        sql_definition = sql_definition.strip_heredoc if sql_definition
         sql_definition ||= Fx::Definition.new(
           name: name,
           version: version,
@@ -116,6 +117,7 @@ module Fx
           raise ArgumentError, "on is required"
         end
 
+        sql_definition = sql_definition.strip_heredoc if sql_definition
         sql_definition ||= Fx::Definition.new(
           name: name,
           version: version,

data/lib/fx/trigger.rb

@@ -1,6 +1,8 @@
 module Fx
   # @api private
   class Trigger
+    include Comparable
+
     attr_reader :name, :definition
     delegate :<=>, to: :name
 

data/lib/fx/version.rb

@@ -1,4 +1,4 @@
 module Fx
   # @api private
-  VERSION = "0.3.0"
+  VERSION = "0.6.1"
 end

data/lib/generators/fx/function/USAGE

@@ -2,6 +2,8 @@ Description:
   Create a new database function for your application. This will create a new
   function definition file and the accompanying migration.
 
+  When --no-migration is passed, skips generating a migration.
+
 Examples:
     rails generate fx:function test
 

data/lib/generators/fx/function/function_generator.rb

@@ -8,6 +8,8 @@ module Fx
       include Rails::Generators::Migration
       source_root File.expand_path("../templates", __FILE__)
 
+      class_option :migration, type: :boolean
+
       def create_functions_directory
         unless function_definition_path.exist?
           empty_directory(function_definition_path)
@@ -23,6 +25,7 @@ module Fx
       end
 
       def create_migration_file
+        return if skip_migration_creation?
         if updating_existing_function?
           migration_template(
             "db/migrate/update_function.erb",
@@ -61,7 +64,7 @@ module Fx
 
         def activerecord_migration_class
           if ActiveRecord::Migration.respond_to?(:current_version)
-            "ActiveRecord::Migration[5.0]"
+            "ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]"
           else
             "ActiveRecord::Migration"
           end
@@ -101,6 +104,17 @@ module Fx
       def previous_definition
         Fx::Definition.new(name: file_name, version: previous_version)
       end
+
+      # Skip creating migration file if:
+      #   - migrations option is nil or false
+      def skip_migration_creation?
+        !migration
+      end
+
+      # True unless explicitly false
+      def migration
+        options[:migration] != false
+      end
     end
   end
 end

data/lib/generators/fx/trigger/USAGE

@@ -5,6 +5,8 @@ Description:
   If a trigger of the given name already exists, create a new version of the
   trigger and a migration to replace the old version with the new.
 
+  When --no-migration is passed, skips generating a migration.
+
 Examples:
 
     rails generate fx:trigger test

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

@@ -9,6 +9,8 @@ module Fx
       source_root File.expand_path("../templates", __FILE__)
       argument :table_name, type: :hash, required: true
 
+      class_option :migration, type: :boolean
+
       def create_triggers_directory
         unless trigger_definition_path.exist?
           empty_directory(trigger_definition_path)
@@ -20,6 +22,7 @@ module Fx
       end
 
       def create_migration_file
+        return if skip_migration_creation?
         if updating_existing_trigger?
           migration_template(
             "db/migrate/update_trigger.erb",
@@ -58,7 +61,7 @@ module Fx
 
         def activerecord_migration_class
           if ActiveRecord::Migration.respond_to?(:current_version)
-            "ActiveRecord::Migration[5.0]"
+            "ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]"
           else
             "ActiveRecord::Migration"
           end
@@ -111,6 +114,17 @@ module Fx
       def trigger_definition_path
         @_trigger_definition_path ||= Rails.root.join(*["db", "triggers"])
       end
+
+      # Skip creating migration file if:
+      #   - migrations option is nil or false
+      def skip_migration_creation?
+        !migration
+      end
+
+      # True unless explicitly false
+      def migration
+        options[:migration] != false
+      end
     end
   end
 end

data/spec/acceptance/user_manages_functions_spec.rb

@@ -34,4 +34,24 @@ describe "User manages functions" do
     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", <<-EOS
+      CREATE FUNCTION adder(x int, y int)
+      RETURNS int AS $$
+      BEGIN
+          RETURN $1 + $2;
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    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_helper.rb

@@ -23,7 +23,8 @@ RSpec.configure do |config|
     Dir.chdir("spec/dummy") do
       ActiveRecord::Base.connection.disconnect!
       system <<-CMD
-        rake db:drop db:create &&
+        echo &&
+        rake db:environment:set db:drop db:create &&
         git add -A &&
         git reset --hard HEAD 1>/dev/null &&
         rm -rf .git/ 1>/dev/null

data/spec/dummy/Rakefile

@@ -4,3 +4,10 @@
 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/fx/adapters/postgres/functions_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+module Fx
+  module Adapters
+    describe Postgres::Functions, :db do
+      describe ".all" do
+        it "returns `Function` objects" do
+          connection = ActiveRecord::Base.connection
+          connection.execute <<-EOS.strip_heredoc
+            CREATE OR REPLACE FUNCTION test()
+            RETURNS text AS $$
+            BEGIN
+                RETURN 'test';
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+
+          functions = Postgres::Functions.new(connection).all
+
+          first = functions.first
+          expect(functions.size).to eq 1
+          expect(first.name).to eq "test"
+          expect(first.definition).to eq <<-EOS.strip_heredoc
+            CREATE OR REPLACE FUNCTION public.test()
+             RETURNS text
+             LANGUAGE plpgsql
+            AS $function$
+            BEGIN
+                RETURN 'test';
+            END;
+            $function$
+          EOS
+        end
+      end
+    end
+  end
+end

data/spec/fx/adapters/postgres/triggers_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+module Fx
+  module Adapters
+    describe Postgres::Triggers, :db do
+      describe ".all" do
+        it "returns `Trigger` objects" do
+          connection = ActiveRecord::Base.connection
+          connection.execute <<-EOS.strip_heredoc
+            CREATE TABLE users (
+                id int PRIMARY KEY,
+                name varchar(256),
+                upper_name varchar(256)
+            );
+          EOS
+          connection.execute <<-EOS.strip_heredoc
+            CREATE OR REPLACE FUNCTION uppercase_users_name()
+            RETURNS trigger AS $$
+            BEGIN
+              NEW.upper_name = UPPER(NEW.name);
+              RETURN NEW;
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+          connection.execute <<-EOS.strip_heredoc
+            CREATE TRIGGER uppercase_users_name
+                BEFORE INSERT ON users
+                FOR EACH ROW
+                EXECUTE PROCEDURE uppercase_users_name();
+          EOS
+
+          triggers = Postgres::Triggers.new(connection).all
+
+          first = triggers.first
+          expect(triggers.size).to eq 1
+          expect(first.name).to eq "uppercase_users_name"
+          expect(first.definition).to include("BEFORE INSERT")
+          expect(first.definition).to match(/ON [public\.users|users]/)
+          expect(first.definition).to include("FOR EACH ROW")
+          expect(first.definition).to include("EXECUTE PROCEDURE uppercase_users_name()")
+        end
+      end
+    end
+  end
+end

data/spec/fx/adapters/postgres_spec.rb

@@ -53,22 +53,44 @@ module Fx::Adapters
     end
 
     describe "#drop_function" do
-      it "successfully drops a function" do
-        adapter = Postgres.new
-        adapter.create_function(
-          <<-EOS
-            CREATE OR REPLACE FUNCTION test()
-            RETURNS text AS $$
-            BEGIN
-                RETURN 'test';
-            END;
-            $$ LANGUAGE plpgsql;
-          EOS
-        )
+      context "when the function has arguments" do
+        it "successfully drops a function with the entire function signature" do
+          adapter = Postgres.new
+          adapter.create_function(
+            <<-EOS
+              CREATE FUNCTION adder(x int, y int)
+              RETURNS int AS $$
+              BEGIN
+                  RETURN $1 + $2;
+              END;
+              $$ LANGUAGE plpgsql;
+            EOS
+          )
+
+          adapter.drop_function(:adder)
+
+          expect(adapter.functions.map(&:name)).not_to include("adder")
+        end
+      end
+
+      context "when the function does not have arguments" do
+        it "successfully drops a function" do
+          adapter = Postgres.new
+          adapter.create_function(
+            <<-EOS
+              CREATE OR REPLACE FUNCTION test()
+              RETURNS text AS $$
+              BEGIN
+                  RETURN 'test';
+              END;
+              $$ LANGUAGE plpgsql;
+            EOS
+          )
 
-        adapter.drop_function(:test)
+          adapter.drop_function(:test)
 
-        expect(adapter.functions.map(&:name)).not_to include("test")
+          expect(adapter.functions.map(&:name)).not_to include("test")
+        end
       end
     end
 

data/spec/fx/definition_spec.rb

@@ -28,6 +28,29 @@ describe Fx::Definition do
           %r(Define function in db/functions/test_v01.sql before migrating),
         )
       end
+
+      context "when definition is at Rails engine" do
+        it "returns the content of a function definition" do
+          sql_definition = <<-EOS
+            CREATE OR REPLACE FUNCTION test()
+            RETURNS text AS $$
+            BEGIN
+                RETURN 'test';
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+          engine_path = Rails.root.join("tmp", "engine")
+          FileUtils.mkdir_p(engine_path.join("db", "functions"))
+          File.write(engine_path.join("db", "functions", "custom_test_v01.sql"), sql_definition)
+          Rails.application.config.paths["db/migrate"].push(engine_path.join("db", "migrate"))
+
+          definition = Fx::Definition.new(name: "custom_test", version: 1)
+
+          expect(definition.to_sql).to eq sql_definition
+
+          FileUtils.rm_rf(engine_path)
+        end
+      end
     end
 
     context "representing a trigger definition" do

data/spec/fx/function_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "fx/function"
+
+module Fx
+  describe Function do
+    describe "#<=>" do
+      it "delegates to `name`" do
+        function_a = Function.new(
+          "name" => "name_a",
+          "definition" => "some defintion",
+        )
+        function_b = Function.new(
+          "name" => "name_b",
+          "definition" => "some defintion",
+        )
+        function_c = Function.new(
+          "name" => "name_c",
+          "definition" => "some defintion",
+        )
+
+        expect(function_b).to be_between(function_a, function_c)
+      end
+    end
+
+    describe "#==" do
+      it "compares `name` and `definition`" do
+        function_a = Function.new(
+          "name" => "name_a",
+          "definition" => "some defintion",
+        )
+        function_b = Function.new(
+          "name" => "name_b",
+          "definition" => "some other defintion",
+        )
+
+        expect(function_a).not_to eq(function_b)
+      end
+    end
+
+    describe "#to_schema" do
+      it "returns a schema compatible version of the function" do
+        function = Function.new(
+          "name" => "uppercase_users_name",
+          "definition" => "CREATE OR REPLACE TRIGGER uppercase_users_name ...",
+        )
+
+        expect(function.to_schema).to eq <<-EOS
+  create_function :uppercase_users_name, sql_definition: <<-\SQL
+      CREATE OR REPLACE TRIGGER uppercase_users_name ...
+  SQL
+        EOS
+      end
+    end
+  end
+end