fx 0.1.0

data/lib/fx/adapters/postgres/connection.rb

@@ -0,0 +1,16 @@
+module Fx
+  module Adapters
+    class Postgres
+      # Decorates an ActiveRecord connection with methods that help determine
+      # the connections capabilities.
+      #
+      # Every attempt is made to use the versions of these methods defined by
+      # Rails where they are available and public before falling back to our own
+      # implementations for older Rails versions.
+      #
+      # @api private
+      class Connection < SimpleDelegator
+      end
+    end
+  end
+end

data/lib/fx/adapters/postgres/functions.rb

@@ -0,0 +1,55 @@
+require "fx/function"
+
+module Fx
+  module Adapters
+    class Postgres
+      # Fetches defined functions from the postgres connection.
+      # @api private
+      class Functions
+        # The SQL query used by F(x) to retrieve the functions considered
+        # dumpable into `db/schema.rb`.
+        FUNCTIONS_WITH_DEFINITIONS_QUERY = <<~SQL
+          SELECT
+              pp.proname AS name,
+              pg_get_functiondef(pp.oid) AS definition
+          FROM pg_proc pp
+          JOIN pg_namespace pn
+              ON pn.oid = pp.pronamespace
+          LEFT JOIN pg_depend pd
+              ON pd.objid = pp.oid AND pd.deptype = 'e'
+          WHERE pn.nspname = 'public' AND pd.objid IS NULL;
+        SQL
+
+        # Wraps #all as a static facade.
+        #
+        # @return [Array<Fx::Function>]
+        def self.all(*args)
+          new(*args).all
+        end
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        # All of the functions that this connection has defined.
+        #
+        # @return [Array<Fx::Function>]
+        def all
+          functions_from_postgres.map { |function| to_fx_function(function) }
+        end
+
+        private
+
+        attr_reader :connection
+
+        def functions_from_postgres
+          connection.execute(FUNCTIONS_WITH_DEFINITIONS_QUERY)
+        end
+
+        def to_fx_function(result)
+          Fx::Function.new(result)
+        end
+      end
+    end
+  end
+end

data/lib/fx/adapters/postgres/triggers.rb

@@ -0,0 +1,56 @@
+require "fx/trigger"
+
+module Fx
+  module Adapters
+    class Postgres
+      # Fetches defined triggers from the postgres connection.
+      # @api private
+      class Triggers
+        # The SQL query used by F(x) to retrieve the triggers considered
+        # dumpable into `db/schema.rb`.
+        TRIGGERS_WITH_DEFINITIONS_QUERY = <<~SQL
+          SELECT
+              pt.tgname AS name,
+              pg_get_triggerdef(pt.oid) AS definition
+          FROM pg_trigger pt
+          JOIN pg_class pc
+              ON (pc.oid = pt.tgrelid)
+          JOIN pg_proc pp
+              ON (pp.oid = pt.tgfoid)
+          WHERE pt.tgname
+          NOT ILIKE '%constraint%' AND pt.tgname NOT ILIKE 'pg%';
+        SQL
+
+        # Wraps #all as a static facade.
+        #
+        # @return [Array<Fx::Trigger>]
+        def self.all(*args)
+          new(*args).all
+        end
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        # All of the triggers that this connection has defined.
+        #
+        # @return [Array<Fx::Trigger>]
+        def all
+          triggers_from_postgres.map { |trigger| to_fx_trigger(trigger) }
+        end
+
+        private
+
+        attr_reader :connection
+
+        def triggers_from_postgres
+          connection.execute(TRIGGERS_WITH_DEFINITIONS_QUERY)
+        end
+
+        def to_fx_trigger(result)
+          Fx::Trigger.new(result)
+        end
+      end
+    end
+  end
+end

data/lib/fx/command_recorder.rb

@@ -0,0 +1,29 @@
+require "fx/command_recorder/arguments"
+require "fx/command_recorder/function"
+require "fx/command_recorder/trigger"
+
+module Fx
+  # @api private
+  module CommandRecorder
+    include Function
+    include Trigger
+
+    private
+
+    def perform_inversion(method, args)
+      arguments = Arguments.new(args)
+
+      if arguments.revert_to_version.nil?
+        message = "`#{method}` is reversible only if given a `revert_to_version`"
+        raise ActiveRecord::IrreversibleMigration, message
+      end
+
+      [method, arguments.invert_version.to_a]
+    end
+  end
+end
+
+ActiveRecord::Migration::CommandRecorder.send(
+  :include,
+  Fx::CommandRecorder,
+)

data/lib/fx/command_recorder/arguments.rb

@@ -0,0 +1,43 @@
+module Fx
+  module CommandRecorder
+    # @api private
+    class Arguments
+      def initialize(args)
+        @args = args.freeze
+      end
+
+      def function
+        @args[0]
+      end
+
+      def version
+        options[:version]
+      end
+
+      def revert_to_version
+        options[:revert_to_version]
+      end
+
+      def invert_version
+        Arguments.new([function, options_for_revert])
+      end
+
+      def to_a
+        @args.to_a
+      end
+
+      private
+
+      def options
+        @options ||= @args[1] || {}
+      end
+
+      def options_for_revert
+        options.clone.tap do |revert_options|
+          revert_options[:version] = revert_to_version
+          revert_options.delete(:revert_to_version)
+        end
+      end
+    end
+  end
+end

data/lib/fx/command_recorder/function.rb

@@ -0,0 +1,30 @@
+module Fx
+  module CommandRecorder
+    # @api private
+    module Function
+      def create_function(*args)
+        record(:create_function, args)
+      end
+
+      def drop_function(*args)
+        record(:drop_function, args)
+      end
+
+      def update_function(*args)
+        record(:update_function, args)
+      end
+
+      def invert_create_function(args)
+        [:drop_function, args]
+      end
+
+      def invert_drop_function(args)
+        perform_inversion(:create_function, args)
+      end
+
+      def invert_update_function(args)
+        perform_inversion(:update_function, args)
+      end
+    end
+  end
+end

data/lib/fx/command_recorder/trigger.rb

@@ -0,0 +1,30 @@
+module Fx
+  module CommandRecorder
+    # @api private
+    module Trigger
+      def create_trigger(*args)
+        record(:create_trigger, args)
+      end
+
+      def drop_trigger(*args)
+        record(:drop_trigger, args)
+      end
+
+      def update_trigger(*args)
+        record(:update_trigger, args)
+      end
+
+      def invert_create_trigger(args)
+        [:drop_trigger, args]
+      end
+
+      def invert_drop_trigger(args)
+        perform_inversion(:create_trigger, args)
+      end
+
+      def invert_update_trigger(args)
+        perform_inversion(:update_trigger, args)
+      end
+    end
+  end
+end

data/lib/fx/configuration.rb

@@ -0,0 +1,38 @@
+module Fx
+  # @return [Fx::Configuration] F(x)'s current configuration
+  def self.configuration
+    @_configuration ||= Configuration.new
+  end
+
+  # Set F(x)'s configuration
+  #
+  # @param config [Fx::Configuration]
+  def self.configuration=(config)
+    @_configuration = config
+  end
+
+  # Modify F(x)'s current configuration
+  #
+  # @yieldparam [Fx::Configuration] config current F(x) config
+  # ```
+  # Fx.configure do |config|
+  #   config.database = Fx::Adapters::Postgres
+  # end
+  # ```
+  def self.configure
+    yield configuration
+  end
+
+  # F(x)'s configuration object.
+  class Configuration
+    # The F(x) database adapter instance to use when executing SQL.
+    #
+    # Defaults to an instance of {Fx::Adapters::Postgres}
+    # @return Fx adapter
+    attr_accessor :database
+
+    def initialize
+      @database = Fx::Adapters::Postgres.new
+    end
+  end
+end

data/lib/fx/definition.rb

@@ -0,0 +1,36 @@
+module Fx
+  # @api private
+  class Definition
+    def initialize(name:, version:, type: "function")
+      @name = name
+      @version = version.to_i
+      @type = type
+    end
+
+    def to_sql
+      File.read(full_path).tap do |content|
+        if content.empty?
+          raise "Define #{@type} in #{path} before migrating."
+        end
+      end
+    end
+
+    def full_path
+      Rails.root.join(path)
+    end
+
+    def path
+      File.join("db", @type.pluralize, filename)
+    end
+
+    def version
+      @version.to_s.rjust(2, "0")
+    end
+
+    private
+
+    def filename
+      "#{@name}_v#{version}.sql"
+    end
+  end
+end

data/lib/fx/function.rb

@@ -0,0 +1,24 @@
+module Fx
+  # @api private
+  class Function
+    attr_reader :name, :definition
+    delegate :<=>, to: :name
+
+    def initialize(function_row)
+      @name = function_row.fetch("name")
+      @definition = function_row.fetch("definition")
+    end
+
+    def ==(other)
+      name == other.name && definition == other.definition
+    end
+
+    def to_schema
+      <<-SCHEMA.indent(2)
+create_function :#{name}, sql_definition: <<-\SQL
+#{definition.indent(4).rstrip}
+SQL
+      SCHEMA
+    end
+  end
+end

data/lib/fx/schema_dumper.rb

@@ -0,0 +1,15 @@
+require "fx/schema_dumper/function"
+require "fx/schema_dumper/trigger"
+
+module Fx
+  # @api private
+  module SchemaDumper
+    include Function
+    include Trigger
+  end
+end
+
+ActiveRecord::SchemaDumper.send(
+  :prepend,
+  Fx::SchemaDumper,
+)

data/lib/fx/schema_dumper/function.rb

@@ -0,0 +1,29 @@
+require "rails"
+
+module Fx
+  module SchemaDumper
+    # @api private
+    module Function
+      def tables(stream)
+        super
+        functions(stream)
+      end
+
+      def functions(stream)
+        if dumpable_functions_in_database.any?
+          stream.puts
+        end
+
+        dumpable_functions_in_database.each do |function|
+          stream.puts(function.to_schema)
+        end
+      end
+
+      private
+
+      def dumpable_functions_in_database
+        @_dumpable_functions_in_database ||= Fx.database.functions
+      end
+    end
+  end
+end

data/lib/fx/schema_dumper/trigger.rb

@@ -0,0 +1,29 @@
+require "rails"
+
+module Fx
+  module SchemaDumper
+    # @api private
+    module Trigger
+      def tables(stream)
+        super
+        triggers(stream)
+      end
+
+      def triggers(stream)
+        if dumpable_triggers_in_database.any?
+          stream.puts
+        end
+
+        dumpable_triggers_in_database.each do |trigger|
+          stream.puts(trigger.to_schema)
+        end
+      end
+
+      private
+
+      def dumpable_triggers_in_database
+        @_dumpable_triggers_in_database ||= Fx.database.triggers
+      end
+    end
+  end
+end