fx 0.1.0 → 0.11.0

data/spec/fx/command_recorder_spec.rb

@@ -1,21 +1,13 @@
 require "spec_helper"
 
-describe Fx::CommandRecorder, :db do
+RSpec.describe Fx::CommandRecorder, :db do
   describe "#create_function" do
     it "records the created function" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
 
       recorder.create_function :test
 
-      expect(recorder.commands).to eq [[:create_function, [:test], nil]]
-    end
-
-    it "reverts to drop_function" do
-      recorder = ActiveRecord::Migration::CommandRecorder.new
-
-      recorder.create_function :test
-
-      expect(recorder.commands).to eq [[:create_function, [:test], nil]]
+      expect(recorder.commands).to eq([[:create_function, [:test], nil]])
     end
 
     it "reverts to drop_function" do
@@ -23,7 +15,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.revert { recorder.create_function :test }
 
-      expect(recorder.commands).to eq [[:drop_function, [:test]]]
+      expect(recorder.commands).to eq([[:drop_function, [:test]]])
     end
   end
 
@@ -33,54 +25,56 @@ describe Fx::CommandRecorder, :db do
 
       recorder.drop_function :test
 
-      expect(recorder.commands).to eq [[:drop_function, [:test], nil]]
+      expect(recorder.commands).to eq([[:drop_function, [:test], nil]])
     end
 
     it "reverts to create_function with specified revert_to_version" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:test, { revert_to_version: 3 }]
-      revert_args = [:test, { version: 3 }]
+      args = [:test, {revert_to_version: 3}]
+      revert_args = [:test, {version: 3}]
 
       recorder.revert { recorder.drop_function(*args) }
 
-      expect(recorder.commands).to eq [[:create_function, revert_args]]
+      expect(recorder.commands).to eq([[:create_function, revert_args]])
     end
 
     it "raises when reverting without revert_to_version set" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:test, { another_argument: 1 }]
+      args = [:test, {another_argument: 1}]
 
-      expect { recorder.revert { recorder.drop_function(*args) } }.
-        to raise_error(ActiveRecord::IrreversibleMigration)
+      expect do
+        recorder.revert { recorder.drop_function(*args) }
+      end.to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 
   describe "#update_function" do
     it "records the updated function" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:test, { version: 2 }]
+      args = [:test, {version: 2}]
 
       recorder.update_function(*args)
 
-      expect(recorder.commands).to eq [[:update_function, args, nil]]
+      expect(recorder.commands).to eq([[:update_function, args, nil]])
     end
 
     it "reverts to update_function with the specified revert_to_version" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:test, { version: 2, revert_to_version: 1 }]
-      revert_args = [:test, { version: 1 }]
+      args = [:test, {version: 2, revert_to_version: 1}]
+      revert_args = [:test, {version: 1}]
 
       recorder.revert { recorder.update_function(*args) }
 
-      expect(recorder.commands).to eq [[:update_function, revert_args]]
+      expect(recorder.commands).to eq([[:update_function, revert_args]])
     end
 
     it "raises when reverting without revert_to_version set" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:test, { version: 42, another_argument: 1 }]
+      args = [:test, {version: 42, another_argument: 1}]
 
-      expect { recorder.revert { recorder.update_function(*args) } }.
-        to raise_error(ActiveRecord::IrreversibleMigration)
+      expect do
+        recorder.revert { recorder.update_function(*args) }
+      end.to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 
@@ -90,17 +84,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.create_trigger :greetings
 
-      expect(recorder.commands).to eq [[:create_trigger, [:greetings], nil]]
-    end
-
-    it "reverts to drop_trigger" do
-      recorder = ActiveRecord::Migration::CommandRecorder.new
-
-      recorder.create_trigger :greetings
-
-      expect(recorder.commands).to eq [
-        [:create_trigger, [:greetings], nil],
-      ]
+      expect(recorder.commands).to eq([[:create_trigger, [:greetings], nil]])
     end
 
     it "reverts to drop_trigger" do
@@ -108,7 +92,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.revert { recorder.create_trigger :greetings }
 
-      expect(recorder.commands).to eq [[:drop_trigger, [:greetings]]]
+      expect(recorder.commands).to eq([[:drop_trigger, [:greetings]]])
     end
   end
 
@@ -118,54 +102,56 @@ describe Fx::CommandRecorder, :db do
 
       recorder.drop_trigger :users
 
-      expect(recorder.commands).to eq [[:drop_trigger, [:users], nil]]
+      expect(recorder.commands).to eq([[:drop_trigger, [:users], nil]])
     end
 
     it "reverts to create_trigger with specified revert_to_version" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:users, { revert_to_version: 3 }]
-      revert_args = [:users, { version: 3 }]
+      args = [:users, {revert_to_version: 3}]
+      revert_args = [:users, {version: 3}]
 
       recorder.revert { recorder.drop_trigger(*args) }
 
-      expect(recorder.commands).to eq [[:create_trigger, revert_args]]
+      expect(recorder.commands).to eq([[:create_trigger, revert_args]])
     end
 
     it "raises when reverting without revert_to_version set" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:users, { another_argument: 1 }]
+      args = [:users, {another_argument: 1}]
 
-      expect { recorder.revert { recorder.drop_trigger(*args) } }.
-        to raise_error(ActiveRecord::IrreversibleMigration)
+      expect do
+        recorder.revert { recorder.drop_trigger(*args) }
+      end.to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 
   describe "#update_trigger" do
     it "records the updated trigger" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:users, { version: 2 }]
+      args = [:users, {version: 2}]
 
       recorder.update_trigger(*args)
 
-      expect(recorder.commands).to eq [[:update_trigger, args, nil]]
+      expect(recorder.commands).to eq([[:update_trigger, args, nil]])
     end
 
     it "reverts to update_trigger with the specified revert_to_version" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:users, { version: 2, revert_to_version: 1 }]
-      revert_args = [:users, { version: 1 }]
+      args = [:users, {version: 2, revert_to_version: 1}]
+      revert_args = [:users, {version: 1}]
 
       recorder.revert { recorder.update_trigger(*args) }
 
-      expect(recorder.commands).to eq [[:update_trigger, revert_args]]
+      expect(recorder.commands).to eq([[:update_trigger, revert_args]])
     end
 
     it "raises when reverting without revert_to_version set" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:users, { version: 42, another_argument: 1 }]
+      args = [:users, {version: 42, another_argument: 1}]
 
-      expect { recorder.revert { recorder.update_trigger(*args) } }.
-        to raise_error(ActiveRecord::IrreversibleMigration)
+      expect do
+        recorder.revert { recorder.update_trigger(*args) }
+      end.to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 end

data/spec/fx/configuration_spec.rb

@@ -1,21 +1,32 @@
 require "spec_helper"
 
-describe Fx::Configuration do
+RSpec.describe Fx::Configuration do
   it "defaults the database adapter to postgres" do
-    expect(Fx.configuration.database).to be_a Fx::Adapters::Postgres
-    expect(Fx.database).to be_a Fx::Adapters::Postgres
+    configuration = Fx::Configuration.new
+
+    expect(configuration.database).to be_a(Fx::Adapters::Postgres)
+  end
+
+  it "defaults `dump_functions_at_beginning_of_schema` to false" do
+    configuration = Fx::Configuration.new
+
+    expect(configuration.dump_functions_at_beginning_of_schema).to eq(false)
   end
 
   it "allows the database adapter to be set" do
+    configuration = Fx::Configuration.new
     adapter = double("Fx Adapter")
 
-    Fx.configure do |config|
-      config.database = adapter
-    end
+    configuration.database = adapter
+
+    expect(configuration.database).to eq(adapter)
+  end
+
+  it "allows `dump_functions_at_beginning_of_schema` to be set" do
+    configuration = Fx::Configuration.new
 
-    expect(Fx.configuration.database).to eq adapter
-    expect(Fx.database).to eq adapter
+    configuration.dump_functions_at_beginning_of_schema = true
 
-    Fx.configuration = Fx::Configuration.new
+    expect(configuration.dump_functions_at_beginning_of_schema).to eq(true)
   end
 end

data/spec/fx/definition_spec.rb

@@ -1,65 +1,84 @@
 require "spec_helper"
 
-describe Fx::Definition do
+RSpec.describe Fx::Definition do
   describe "#to_sql" do
     context "representing a function definition" do
       it "returns the content of a function definition" do
-        sql_definition = <<~EOS
+        sql_definition = <<~SQL
           CREATE OR REPLACE FUNCTION test()
           RETURNS text AS $$
           BEGIN
               RETURN 'test';
           END;
           $$ LANGUAGE plpgsql;
-        EOS
+        SQL
         allow(File).to receive(:read).and_return(sql_definition)
 
-        definition = Fx::Definition.new(name: "test", version: 1)
+        definition = Fx::Definition.function(name: "test", version: 1)
 
-        expect(definition.to_sql).to eq sql_definition
+        expect(definition.to_sql).to eq(sql_definition)
       end
 
       it "raises an error if the file is empty" do
         allow(File).to receive(:read).and_return("")
-        definition = Fx::Definition.new(name: "test", version: 1)
+        definition = Fx::Definition.function(name: "test", version: 1)
 
-        expect { definition.to_sql }.to raise_error(
+        expect do
+          definition.to_sql
+        end.to raise_error(
           RuntimeError,
-          %r(Define function in db/functions/test_v01.sql before migrating),
+          %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 = <<~SQL
+            CREATE OR REPLACE FUNCTION test()
+            RETURNS text AS $$
+            BEGIN
+                RETURN 'test';
+            END;
+            $$ LANGUAGE plpgsql;
+          SQL
+          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.function(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
       it "returns the content of a trigger definition" do
-        sql_definition = <<~EOS
+        sql_definition = <<~SQL
           CREATE TRIGGER check_update
           BEFORE UPDATE ON accounts
           FOR EACH ROW
-          EXECUTE PROCEDURE check_account_update();
-        EOS
+          EXECUTE FUNCTION check_account_update();
+        SQL
         allow(File).to receive(:read).and_return(sql_definition)
 
-        definition = Fx::Definition.new(
-          name: "test",
-          version: 1,
-          type: "trigger",
-        )
+        definition = Fx::Definition.trigger(name: "test", version: 1)
 
-        expect(definition.to_sql).to eq sql_definition
+        expect(definition.to_sql).to eq(sql_definition)
       end
 
       it "raises an error if the file is empty" do
         allow(File).to receive(:read).and_return("")
-        definition = Fx::Definition.new(
-          name: "test",
-          version: 1,
-          type: "trigger",
-        )
+        definition = Fx::Definition.trigger(name: "test", version: 1)
 
-        expect { definition.to_sql }.to raise_error(
+        expect do
+          definition.to_sql
+        end.to raise_error(
           RuntimeError,
-          %r(Define trigger in db/triggers/test_v01.sql before migrating),
+          %r{Define trigger in db/triggers/test_v01.sql before migrating}
         )
       end
     end
@@ -68,44 +87,40 @@ describe Fx::Definition do
   describe "#path" do
     context "representing a function definition" do
       it "returns a sql file with padded version and function name" do
-        definition = Fx::Definition.new(name: "test", version: 1)
+        definition = Fx::Definition.function(name: "test", version: 1)
 
-        expect(definition.path).to eq "db/functions/test_v01.sql"
+        expect(definition.path).to eq("db/functions/test_v01.sql")
       end
     end
 
     context "representing a trigger definition" do
       it "returns a sql file with padded version and trigger name" do
-        definition = Fx::Definition.new(
-          name: "test",
-          version: 1,
-          type: "trigger",
-        )
+        definition = Fx::Definition.trigger(name: "test", version: 1)
 
-        expect(definition.path).to eq "db/triggers/test_v01.sql"
+        expect(definition.path).to eq("db/triggers/test_v01.sql")
       end
     end
   end
 
   describe "#full_path" do
     it "joins the path with Rails.root" do
-      definition = Fx::Definition.new(name: "test", version: 15)
+      definition = Fx::Definition.function(name: "test", version: 15)
 
-      expect(definition.full_path).to eq Rails.root.join(definition.path)
+      expect(definition.full_path).to eq(Rails.root.join(definition.path))
     end
   end
 
   describe "#version" do
     it "pads the version number with 0" do
-      definition = Fx::Definition.new(name: :_, version: 1)
+      definition = Fx::Definition.function(name: :_, version: 1)
 
-      expect(definition.version).to eq "01"
+      expect(definition.version).to eq("01")
     end
 
     it "does not pad more than 2 characters" do
-      definition = Fx::Definition.new(name: :_, version: 15)
+      definition = Fx::Definition.function(name: :_, version: 15)
 
-      expect(definition.version).to eq "15"
+      expect(definition.version).to eq("15")
     end
   end
 end

data/spec/fx/function_spec.rb

@@ -0,0 +1,143 @@
+require "spec_helper"
+
+RSpec.describe Fx::Function do
+  describe "#<=>" do
+    it "delegates to `signature`" do
+      function_a = Fx::Function.new(
+        "name" => "name_a",
+        "definition" => "some definition",
+        "arguments" => ""
+      )
+      function_b = Fx::Function.new(
+        "name" => "name_b",
+        "definition" => "some definition",
+        "arguments" => ""
+      )
+      function_c = Fx::Function.new(
+        "name" => "name_c",
+        "definition" => "some definition",
+        "arguments" => ""
+      )
+
+      expect(function_b).to be_between(function_a, function_c)
+    end
+
+    it "orders overloads by signature" do
+      add_int = Fx::Function.new(
+        "name" => "add",
+        "definition" => "some definition",
+        "arguments" => "integer, integer"
+      )
+      add_text = Fx::Function.new(
+        "name" => "add",
+        "definition" => "some definition",
+        "arguments" => "text, text"
+      )
+
+      expect(add_int <=> add_text).to be < 0
+    end
+  end
+
+  describe "#==" do
+    it "compares `signature` and `definition`" do
+      function_a = Fx::Function.new(
+        "name" => "name_a",
+        "definition" => "some definition",
+        "arguments" => ""
+      )
+      function_b = Fx::Function.new(
+        "name" => "name_b",
+        "definition" => "some other definition",
+        "arguments" => ""
+      )
+
+      expect(function_a).not_to eq(function_b)
+    end
+
+    it "distinguishes overloads with the same name" do
+      add_int = Fx::Function.new(
+        "name" => "add",
+        "definition" => "CREATE FUNCTION add(integer)",
+        "arguments" => "integer"
+      )
+      add_text = Fx::Function.new(
+        "name" => "add",
+        "definition" => "CREATE FUNCTION add(text)",
+        "arguments" => "text"
+      )
+
+      expect(add_int).not_to eq(add_text)
+    end
+  end
+
+  describe "#signature" do
+    it "returns name with arguments when arguments are present" do
+      function = Fx::Function.new(
+        "name" => "inc",
+        "definition" => "some definition",
+        "arguments" => "integer"
+      )
+
+      expect(function.signature).to eq("inc(integer)")
+    end
+
+    it "returns name with multiple arguments" do
+      function = Fx::Function.new(
+        "name" => "add",
+        "definition" => "some definition",
+        "arguments" => "integer, integer"
+      )
+
+      expect(function.signature).to eq("add(integer, integer)")
+    end
+
+    it "returns name with empty parens for no-arg functions" do
+      function = Fx::Function.new(
+        "name" => "now_utc",
+        "definition" => "some definition",
+        "arguments" => ""
+      )
+
+      expect(function.signature).to eq("now_utc()")
+    end
+
+    it "returns just the name when arguments key is missing" do
+      function = Fx::Function.new(
+        "name" => "now_utc",
+        "definition" => "some definition"
+      )
+
+      expect(function.signature).to eq("now_utc")
+    end
+  end
+
+  describe "#to_schema" do
+    it "returns a schema compatible version of the function" do
+      function = Fx::Function.new(
+        "name" => "uppercase_users_name",
+        "definition" => "CREATE OR REPLACE TRIGGER uppercase_users_name ...",
+        "arguments" => ""
+      )
+
+      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
+
+    it "maintains backslashes" do
+      function = Fx::Function.new(
+        "name" => "regex",
+        "definition" => "CREATE OR REPLACE FUNCTION regex \\1",
+        "arguments" => ""
+      )
+
+      expect(function.to_schema).to eq(<<-'EOS')
+  create_function :regex, sql_definition: <<-'SQL'
+      CREATE OR REPLACE FUNCTION regex \1
+  SQL
+      EOS
+    end
+  end
+end