fx 0.7.0 → 0.8.0

data/spec/features/triggers/revert_spec.rb

@@ -22,11 +22,11 @@ describe "Reverting migrations", :db do
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
+          EXECUTE FUNCTION uppercase_users_name();
     EOS
     with_trigger_definition(
       name: :uppercase_users_name,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
       example.run
     end
@@ -57,10 +57,10 @@ describe "Reverting migrations", :db do
     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_trigger` is reversible only if given a `revert_to_version`/,
+        /`create_trigger` is reversible only if given a `revert_to_version`/
       )
   end
 
@@ -71,12 +71,12 @@ describe "Reverting migrations", :db do
       CREATE TRIGGER uppercase_users_name
           BEFORE UPDATE ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
+          EXECUTE FUNCTION uppercase_users_name();
     EOS
     with_trigger_definition(
       name: :uppercase_users_name,
       sql_definition: sql_definition,
-      version: 2,
+      version: 2
     ) do
       migration = Class.new(migration_class) do
         def change
@@ -84,7 +84,7 @@ describe "Reverting migrations", :db do
             :uppercase_users_name,
             on: :users,
             version: 2,
-            revert_to_version: 1,
+            revert_to_version: 1
           )
         end
       end

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

@@ -26,7 +26,7 @@ module Fx
             CREATE TRIGGER uppercase_users_name
                 BEFORE INSERT ON users
                 FOR EACH ROW
-                EXECUTE PROCEDURE uppercase_users_name();
+                EXECUTE FUNCTION uppercase_users_name();
           EOS
 
           triggers = Postgres::Triggers.new(connection).all
@@ -35,9 +35,9 @@ module Fx
           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 match(/ON [public.ser|]/)
           expect(first.definition).to include("FOR EACH ROW")
-          expect(first.definition).to include("EXECUTE PROCEDURE uppercase_users_name()")
+          expect(first.definition).to include("EXECUTE FUNCTION uppercase_users_name()")
         end
       end
     end

data/spec/fx/adapters/postgres_spec.rb

@@ -44,7 +44,7 @@ module Fx::Adapters
             CREATE TRIGGER uppercase_users_name
                 BEFORE INSERT ON users
                 FOR EACH ROW
-                EXECUTE PROCEDURE uppercase_users_name();
+                EXECUTE FUNCTION uppercase_users_name();
           EOS
         )
 
@@ -135,7 +135,7 @@ module Fx::Adapters
           CREATE TRIGGER uppercase_users_name
               BEFORE INSERT ON users
               FOR EACH ROW
-              EXECUTE PROCEDURE uppercase_users_name()
+              EXECUTE FUNCTION uppercase_users_name()
         EOS
         adapter.create_trigger(sql_definition)
 

data/spec/fx/command_recorder/arguments_spec.rb

@@ -4,7 +4,7 @@ module Fx::CommandRecorder
   describe Arguments do
     describe "#function" do
       it "returns the function name" do
-        raw_args = [:spaceships, { foo: :bar }]
+        raw_args = [:spaceships, {foo: :bar}]
         args = Arguments.new(raw_args)
 
         expect(args.function).to eq :spaceships
@@ -13,14 +13,14 @@ module Fx::CommandRecorder
 
     describe "#revert_to_version" do
       it "is the revert_to_version from the keyword arguments" do
-        raw_args = [:spaceships, { revert_to_version: 42 }]
+        raw_args = [:spaceships, {revert_to_version: 42}]
         args = Arguments.new(raw_args)
 
         expect(args.revert_to_version).to eq 42
       end
 
       it "is nil if the revert_to_version was not supplied" do
-        raw_args = [:spaceships, { foo: :bar }]
+        raw_args = [:spaceships, {foo: :bar}]
         args = Arguments.new(raw_args)
 
         expect(args.revert_to_version).to be nil
@@ -29,7 +29,7 @@ module Fx::CommandRecorder
 
     describe "#invert_version" do
       it "returns object with version set to revert_to_version" do
-        raw_args = [:meatballs, { version: 42, revert_to_version: 15 }]
+        raw_args = [:meatballs, {version: 42, revert_to_version: 15}]
 
         inverted_args = Arguments.new(raw_args).invert_version
 

data/spec/fx/command_recorder_spec.rb

@@ -38,8 +38,8 @@ describe Fx::CommandRecorder, :db do
 
     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) }
 
@@ -48,17 +48,17 @@ describe Fx::CommandRecorder, :db do
 
     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 { recorder.revert { recorder.drop_function(*args) } }
+        .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)
 
@@ -67,8 +67,8 @@ describe Fx::CommandRecorder, :db do
 
     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) }
 
@@ -77,10 +77,10 @@ describe Fx::CommandRecorder, :db do
 
     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 { recorder.revert { recorder.update_function(*args) } }
+        .to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 
@@ -99,7 +99,7 @@ describe Fx::CommandRecorder, :db do
       recorder.create_trigger :greetings
 
       expect(recorder.commands).to eq [
-        [:create_trigger, [:greetings], nil],
+        [:create_trigger, [:greetings], nil]
       ]
     end
 
@@ -123,8 +123,8 @@ describe Fx::CommandRecorder, :db do
 
     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) }
 
@@ -133,17 +133,17 @@ describe Fx::CommandRecorder, :db do
 
     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 { recorder.revert { recorder.drop_trigger(*args) } }
+        .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)
 
@@ -152,8 +152,8 @@ describe Fx::CommandRecorder, :db do
 
     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) }
 
@@ -162,10 +162,10 @@ describe Fx::CommandRecorder, :db do
 
     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 { recorder.revert { recorder.update_trigger(*args) } }
+        .to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 end

data/spec/fx/definition_spec.rb

@@ -25,7 +25,7 @@ describe Fx::Definition do
 
         expect { definition.to_sql }.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
 
@@ -59,14 +59,14 @@ describe Fx::Definition do
           CREATE TRIGGER check_update
           BEFORE UPDATE ON accounts
           FOR EACH ROW
-          EXECUTE PROCEDURE check_account_update();
+          EXECUTE FUNCTION check_account_update();
         EOS
         allow(File).to receive(:read).and_return(sql_definition)
 
         definition = Fx::Definition.new(
           name: "test",
           version: 1,
-          type: "trigger",
+          type: "trigger"
         )
 
         expect(definition.to_sql).to eq sql_definition
@@ -77,12 +77,12 @@ describe Fx::Definition do
         definition = Fx::Definition.new(
           name: "test",
           version: 1,
-          type: "trigger",
+          type: "trigger"
         )
 
         expect { definition.to_sql }.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
@@ -102,7 +102,7 @@ describe Fx::Definition do
         definition = Fx::Definition.new(
           name: "test",
           version: 1,
-          type: "trigger",
+          type: "trigger"
         )
 
         expect(definition.path).to eq "db/triggers/test_v01.sql"

data/spec/fx/function_spec.rb

@@ -7,15 +7,15 @@ module Fx
       it "delegates to `name`" do
         function_a = Function.new(
           "name" => "name_a",
-          "definition" => "some definition",
+          "definition" => "some definition"
         )
         function_b = Function.new(
           "name" => "name_b",
-          "definition" => "some definition",
+          "definition" => "some definition"
         )
         function_c = Function.new(
           "name" => "name_c",
-          "definition" => "some definition",
+          "definition" => "some definition"
         )
 
         expect(function_b).to be_between(function_a, function_c)
@@ -26,11 +26,11 @@ module Fx
       it "compares `name` and `definition`" do
         function_a = Function.new(
           "name" => "name_a",
-          "definition" => "some definition",
+          "definition" => "some definition"
         )
         function_b = Function.new(
           "name" => "name_b",
-          "definition" => "some other definition",
+          "definition" => "some other definition"
         )
 
         expect(function_a).not_to eq(function_b)
@@ -41,10 +41,10 @@ module Fx
       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 ...",
+          "definition" => "CREATE OR REPLACE TRIGGER uppercase_users_name ..."
         )
 
-        expect(function.to_schema).to eq <<-'EOS'
+        expect(function.to_schema).to eq <<-EOS
   create_function :uppercase_users_name, sql_definition: <<-'SQL'
       CREATE OR REPLACE TRIGGER uppercase_users_name ...
   SQL
@@ -54,7 +54,7 @@ module Fx
       it "maintains backslashes" do
         function = Function.new(
           "name" => "regex",
-          "definition" => "CREATE OR REPLACE FUNCTION regex \\1",
+          "definition" => "CREATE OR REPLACE FUNCTION regex \\1"
         )
 
         expect(function.to_schema).to eq <<-'EOS'

data/spec/fx/schema_dumper/function_spec.rb

@@ -18,34 +18,32 @@ describe Fx::SchemaDumper::Function, :db do
     ActiveRecord::SchemaDumper.dump(connection, stream)
 
     expect(output).to(
-      match(/table "my_table".*function :my_function.*RETURN 'test';/m),
+      match(/table "my_table".*function :my_function.*RETURN 'test';/m)
     )
   end
 
   it "dumps a create_function for a function in the database" do
-    begin
-      Fx.configuration.dump_functions_at_beginning_of_schema = true
-      sql_definition = <<-EOS
+    Fx.configuration.dump_functions_at_beginning_of_schema = true
+    sql_definition = <<-EOS
         CREATE OR REPLACE FUNCTION my_function()
         RETURNS text AS $$
         BEGIN
             RETURN 'test';
         END;
         $$ LANGUAGE plpgsql;
-      EOS
-      connection.create_function :my_function, sql_definition: sql_definition
-      connection.create_table :my_table
-      stream = StringIO.new
-      output = stream.string
+    EOS
+    connection.create_function :my_function, sql_definition: sql_definition
+    connection.create_table :my_table
+    stream = StringIO.new
+    output = stream.string
 
-      ActiveRecord::SchemaDumper.dump(connection, stream)
+    ActiveRecord::SchemaDumper.dump(connection, stream)
 
-      expect(output).to(
-        match(/function :my_function.*RETURN 'test';.*table "my_table"/m),
-      )
-    ensure
-      Fx.configuration.dump_functions_at_beginning_of_schema = false
-    end
+    expect(output).to(
+      match(/function :my_function.*RETURN 'test';.*table "my_table"/m)
+    )
+  ensure
+    Fx.configuration.dump_functions_at_beginning_of_schema = false
   end
 
   it "does not dump a create_function for aggregates in the database" do

data/spec/fx/schema_dumper/trigger_spec.rb

@@ -22,11 +22,11 @@ describe Fx::SchemaDumper::Trigger, :db do
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
+          EXECUTE FUNCTION uppercase_users_name();
     EOS
     connection.create_trigger(
       :uppercase_users_name,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     )
     stream = StringIO.new
 
@@ -35,6 +35,6 @@ describe Fx::SchemaDumper::Trigger, :db do
     output = stream.string
     expect(output).to include "create_trigger :uppercase_users_name"
     expect(output).to include "sql_definition: <<-SQL"
-    expect(output).to include "EXECUTE PROCEDURE uppercase_users_name()"
+    expect(output).to include "EXECUTE FUNCTION uppercase_users_name()"
   end
 end

data/spec/fx/statements/function_spec.rb

@@ -9,10 +9,10 @@ describe Fx::Statements::Function, :db do
 
       connection.create_function(:test)
 
-      expect(database).to have_received(:create_function).
-        with(definition.to_sql)
-      expect(Fx::Definition).to have_received(:new).
-        with(name: :test, version: 1)
+      expect(database).to have_received(:create_function)
+        .with(definition.to_sql)
+      expect(Fx::Definition).to have_received(:new)
+        .with(name: :test, version: 1)
     end
 
     it "allows creating a function with a specific version" do
@@ -21,10 +21,10 @@ describe Fx::Statements::Function, :db do
 
       connection.create_function(:test, version: 2)
 
-      expect(database).to have_received(:create_function).
-        with(definition.to_sql)
-      expect(Fx::Definition).to have_received(:new).
-        with(name: :test, version: 2)
+      expect(database).to have_received(:create_function)
+        .with(definition.to_sql)
+      expect(Fx::Definition).to have_received(:new)
+        .with(name: :test, version: 2)
     end
 
     it "raises an error if both arguments are nil" do
@@ -32,11 +32,11 @@ describe Fx::Statements::Function, :db do
         connection.create_function(
           :whatever,
           version: nil,
-          sql_definition: nil,
+          sql_definition: nil
         )
       }.to raise_error(
         ArgumentError,
-        /version or sql_definition must be specified/,
+        /version or sql_definition must be specified/
       )
     end
   end
@@ -58,10 +58,10 @@ describe Fx::Statements::Function, :db do
 
       connection.update_function(:test, version: 3)
 
-      expect(database).to have_received(:update_function).
-        with(:test, definition.to_sql)
-      expect(Fx::Definition).to have_received(:new).
-        with(name: :test, version: 3)
+      expect(database).to have_received(:update_function)
+        .with(:test, definition.to_sql)
+      expect(Fx::Definition).to have_received(:new)
+        .with(name: :test, version: 3)
     end
 
     it "updates a function from a text definition" do
@@ -71,7 +71,7 @@ describe Fx::Statements::Function, :db do
 
       expect(database).to have_received(:update_function).with(
         :test,
-        "a definition",
+        "a definition"
       )
     end
 
@@ -80,11 +80,11 @@ describe Fx::Statements::Function, :db do
         connection.update_function(
           :whatever,
           version: nil,
-          sql_definition: nil,
+          sql_definition: nil
         )
       }.to raise_error(
         ArgumentError,
-        /version or sql_definition must be specified/,
+        /version or sql_definition must be specified/
       )
     end
   end

data/spec/fx/statements/trigger_spec.rb

@@ -9,10 +9,10 @@ describe Fx::Statements::Trigger, :db do
 
       connection.create_trigger(:test)
 
-      expect(database).to have_received(:create_trigger).
-        with(definition.to_sql)
-      expect(Fx::Definition).to have_received(:new).
-        with(name: :test, version: 1, type: "trigger")
+      expect(database).to have_received(:create_trigger)
+        .with(definition.to_sql)
+      expect(Fx::Definition).to have_received(:new)
+        .with(name: :test, version: 1, type: "trigger")
     end
 
     it "allows creating a trigger with a specific version" do
@@ -21,10 +21,10 @@ describe Fx::Statements::Trigger, :db do
 
       connection.create_trigger(:test, version: 2)
 
-      expect(database).to have_received(:create_trigger).
-        with(definition.to_sql)
-      expect(Fx::Definition).to have_received(:new).
-        with(name: :test, version: 2, type: "trigger")
+      expect(database).to have_received(:create_trigger)
+        .with(definition.to_sql)
+      expect(Fx::Definition).to have_received(:new)
+        .with(name: :test, version: 2, type: "trigger")
     end
 
     it "raises an error if both arguments are set" do
@@ -34,11 +34,11 @@ describe Fx::Statements::Trigger, :db do
         connection.create_trigger(
           :whatever,
           version: 1,
-          sql_definition: "a definition",
+          sql_definition: "a definition"
         )
       }.to raise_error(
         ArgumentError,
-        /cannot both be set/,
+        /cannot both be set/
       )
     end
   end
@@ -49,8 +49,8 @@ describe Fx::Statements::Trigger, :db do
 
       connection.drop_trigger(:test, on: :users)
 
-      expect(database).to have_received(:drop_trigger).
-        with(:test, on: :users)
+      expect(database).to have_received(:drop_trigger)
+        .with(:test, on: :users)
     end
   end
 
@@ -64,12 +64,12 @@ describe Fx::Statements::Trigger, :db do
       expect(database).to have_received(:update_trigger).with(
         :test,
         on: :users,
-        sql_definition: definition.to_sql,
+        sql_definition: definition.to_sql
       )
       expect(Fx::Definition).to have_received(:new).with(
         name: :test,
         version: 3,
-        type: "trigger",
+        type: "trigger"
       )
     end
 
@@ -79,13 +79,13 @@ describe Fx::Statements::Trigger, :db do
       connection.update_trigger(
         :test,
         on: :users,
-        sql_definition: "a definition",
+        sql_definition: "a definition"
       )
 
       expect(database).to have_received(:update_trigger).with(
         :test,
         on: :users,
-        sql_definition: "a definition",
+        sql_definition: "a definition"
       )
     end
 
@@ -94,11 +94,11 @@ describe Fx::Statements::Trigger, :db do
         connection.update_trigger(
           :whatever,
           version: nil,
-          sql_definition: nil,
+          sql_definition: nil
         )
       }.to raise_error(
         ArgumentError,
-        /version or sql_definition must be specified/,
+        /version or sql_definition must be specified/
       )
     end
 
@@ -109,11 +109,11 @@ describe Fx::Statements::Trigger, :db do
         connection.update_trigger(
           :whatever,
           version: 1,
-          sql_definition: "a definition",
+          sql_definition: "a definition"
         )
       }.to raise_error(
         ArgumentError,
-        /cannot both be set/,
+        /cannot both be set/
       )
     end
   end

data/spec/fx/trigger_spec.rb

@@ -7,15 +7,15 @@ module Fx
       it "delegates to `name`" do
         trigger_a = Trigger.new(
           "name" => "name_a",
-          "definition" => "some definition",
+          "definition" => "some definition"
         )
         trigger_b = Trigger.new(
           "name" => "name_b",
-          "definition" => "some definition",
+          "definition" => "some definition"
         )
         trigger_c = Trigger.new(
           "name" => "name_c",
-          "definition" => "some definition",
+          "definition" => "some definition"
         )
 
         expect(trigger_b).to be_between(trigger_a, trigger_c)
@@ -26,11 +26,11 @@ module Fx
       it "compares `name` and `definition`" do
         trigger_a = Trigger.new(
           "name" => "name_a",
-          "definition" => "some definition",
+          "definition" => "some definition"
         )
         trigger_b = Trigger.new(
           "name" => "name_b",
-          "definition" => "some other definition",
+          "definition" => "some other definition"
         )
 
         expect(trigger_a).not_to eq(trigger_b)
@@ -41,7 +41,7 @@ module Fx
       it "returns a schema compatible version of the trigger" do
         trigger = Trigger.new(
           "name" => "uppercase_users_name",
-          "definition" => "CREATE TRIGGER uppercase_users_name ...",
+          "definition" => "CREATE TRIGGER uppercase_users_name ..."
         )
 
         expect(trigger.to_schema).to eq <<-EOS