pg_objects 1.4.8 → 1.5.0

data/lib/pg_objects/parsed_object/operator_class.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # OPERATOR CLASS object representation
 #
 class PgObjects::ParsedObject::OperatorClass < PgObjects::ParsedObject::Base
   def name
-    stmt.create_op_class_stmt.opclassname[0].string.sval
+    extract_name { stmt.create_op_class_stmt.opclassname.last.string.sval }
+  end
+
+  private
+
+  def schema
+    extract_name { qualifier(stmt.create_op_class_stmt.opclassname) }
   end
 end

data/lib/pg_objects/parsed_object/policy.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+#
+# POLICY object representation
+#
+class PgObjects::ParsedObject::Policy < PgObjects::ParsedObject::Base
+  def name
+    extract_name { stmt.create_policy_stmt.policy_name }
+  end
+end

data/lib/pg_objects/parsed_object/range_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+#
+# RANGE TYPE object representation (CREATE TYPE ... AS RANGE)
+#
+class PgObjects::ParsedObject::RangeType < PgObjects::ParsedObject::Base
+  def name
+    extract_name { stmt.create_range_stmt.type_name.last.string.sval }
+  end
+
+  private
+
+  def schema
+    extract_name { qualifier(stmt.create_range_stmt.type_name) }
+  end
+end

data/lib/pg_objects/parsed_object/rule.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+#
+# RULE object representation
+#
+class PgObjects::ParsedObject::Rule < PgObjects::ParsedObject::Base
+  def name
+    extract_name { stmt.rule_stmt.rulename }
+  end
+end

data/lib/pg_objects/parsed_object/sequence.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+#
+# SEQUENCE object representation
+#
+class PgObjects::ParsedObject::Sequence < PgObjects::ParsedObject::Base
+  def name
+    extract_name { stmt.create_seq_stmt.sequence.relname }
+  end
+
+  private
+
+  def schema
+    extract_name { stmt.create_seq_stmt.sequence.schemaname }
+  end
+end

data/lib/pg_objects/parsed_object/table.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # TABLE object representation
 #
 class PgObjects::ParsedObject::Table < PgObjects::ParsedObject::Base
   def name
-    stmt.create_stmt.relation.relname
+    extract_name { stmt.create_stmt.relation.relname }
+  end
+
+  private
+
+  def schema
+    extract_name { stmt.create_stmt.relation.schemaname }
   end
 end

data/lib/pg_objects/parsed_object/text_search_parser.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # TEXT SEARCH PARSER object representation
 #
 class PgObjects::ParsedObject::TextSearchParser < PgObjects::ParsedObject::Base
   def name
-    stmt.define_stmt.defnames[0].string.sval
+    extract_name { stmt.define_stmt.defnames.last.string.sval }
+  end
+
+  private
+
+  def schema
+    extract_name { qualifier(stmt.define_stmt.defnames) }
   end
 end

data/lib/pg_objects/parsed_object/text_search_template.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # TEXT SEARCH TEMPLATE object representation
 #
 class PgObjects::ParsedObject::TextSearchTemplate < PgObjects::ParsedObject::Base
   def name
-    stmt.define_stmt.defnames[0].string.sval
+    extract_name { stmt.define_stmt.defnames.last.string.sval }
+  end
+
+  private
+
+  def schema
+    extract_name { qualifier(stmt.define_stmt.defnames) }
   end
 end

data/lib/pg_objects/parsed_object/trigger.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 #
 # TRIGGER object representation
 #
 class PgObjects::ParsedObject::Trigger < PgObjects::ParsedObject::Base
   def name
-    stmt.create_trig_stmt.trigname
+    extract_name { stmt.create_trig_stmt.trigname }
   end
 end

data/lib/pg_objects/parsed_object/type.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # TYPE object representation
 #
 class PgObjects::ParsedObject::Type < PgObjects::ParsedObject::Base
   def name
-    stmt.composite_type_stmt.typevar.relname
+    extract_name { stmt.composite_type_stmt.typevar.relname }
+  end
+
+  private
+
+  def schema
+    extract_name { stmt.composite_type_stmt.typevar.schemaname }
   end
 end

data/lib/pg_objects/parsed_object/view.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # VIEW object representation
 #
 class PgObjects::ParsedObject::View < PgObjects::ParsedObject::Base
   def name
-    stmt.view_stmt.view.relname
+    extract_name { stmt.view_stmt.view.relname }
+  end
+
+  private
+
+  def schema
+    extract_name { stmt.view_stmt.view.schemaname }
   end
 end

data/lib/pg_objects/parsed_object.rb

@@ -1,14 +1,25 @@
+# frozen_string_literal: true
+
 module PgObjects::ParsedObject # rubocop: disable Style/Documentation
 end
 
 require 'pg_objects/parsed_object/base'
 require 'pg_objects/parsed_object/aggregate'
+require 'pg_objects/parsed_object/base_type'
 require 'pg_objects/parsed_object/conversion'
+require 'pg_objects/parsed_object/domain'
+require 'pg_objects/parsed_object/enum_type'
 require 'pg_objects/parsed_object/event_trigger'
+require 'pg_objects/parsed_object/extension'
 require 'pg_objects/parsed_object/function'
+require 'pg_objects/parsed_object/index'
 require 'pg_objects/parsed_object/materialized_view'
 require 'pg_objects/parsed_object/operator'
 require 'pg_objects/parsed_object/operator_class'
+require 'pg_objects/parsed_object/policy'
+require 'pg_objects/parsed_object/range_type'
+require 'pg_objects/parsed_object/rule'
+require 'pg_objects/parsed_object/sequence'
 require 'pg_objects/parsed_object/table'
 require 'pg_objects/parsed_object/text_search_parser'
 require 'pg_objects/parsed_object/text_search_template'

data/lib/pg_objects/parsed_object_factory.rb

@@ -1,103 +1,65 @@
+# frozen_string_literal: true
+
 #
 # Returns an object of the respective class based on the provided parsed query
 #
 class PgObjects::ParsedObjectFactory
-  class << self
-    include Dry::Monads[:try, :result]
-
-    SUPPORTED_TYPES = %i[
-      aggregate
-      conversion
-      event_trigger
-      function
-      materialized_view
-      operator
-      operator_class
-      table
-      text_search_parser
-      text_search_template
-      trigger
-      type
-      view
-    ].freeze
-
-    def create_object(input_data)
-      @input_data = input_data
-      @stmt = input_data.tree.stmts[0].stmt
-
-      determine_class.new(stmt)
-    end
-
-    private
-
-    attr_reader :stmt, :input_data
-
-    def determine_class
-      SUPPORTED_TYPES.each do |type|
-        return class_for(type) if send("#{type}?")
-      end
-    end
-
-    def class_for(type)
-      "PgObjects::ParsedObject::#{type.to_s.classify}".constantize
-    end
-
-    def aggregate?
-      try_check_get_result { stmt.define_stmt.kind == :OBJECT_AGGREGATE }
-    end
-
-    def conversion?
-      try_check_get_result { stmt.create_conversion_stmt.conversion_name.present? }
-    end
-
-    def event_trigger?
-      try_check_get_result { stmt.create_event_trig_stmt.trigname.present? }
-    end
-
-    def function?
-      try_check_get_result { stmt.create_function_stmt.funcname.present? }
-    end
-
-    def materialized_view?
-      try_check_get_result { stmt.create_table_as_stmt.objtype == :OBJECT_MATVIEW }
-    end
-
-    def operator_class?
-      try_check_get_result { stmt.create_op_class_stmt.opclassname.present? }
-    end
-
-    def operator?
-      try_check_get_result { stmt.define_stmt.kind == :OBJECT_OPERATOR }
-    end
-
-    def table?
-      try_check_get_result { stmt.create_stmt.table_elts.present? }
-    end
-
-    def text_search_parser?
-      try_check_get_result { stmt.define_stmt.kind == :OBJECT_TSPARSER }
-    end
+  DISPATCH = {
+    composite_type_stmt: PgObjects::ParsedObject::Type,
+    create_conversion_stmt: PgObjects::ParsedObject::Conversion,
+    create_domain_stmt: PgObjects::ParsedObject::Domain,
+    create_enum_stmt: PgObjects::ParsedObject::EnumType,
+    create_event_trig_stmt: PgObjects::ParsedObject::EventTrigger,
+    create_extension_stmt: PgObjects::ParsedObject::Extension,
+    create_function_stmt: PgObjects::ParsedObject::Function,
+    create_op_class_stmt: PgObjects::ParsedObject::OperatorClass,
+    create_policy_stmt: PgObjects::ParsedObject::Policy,
+    create_range_stmt: PgObjects::ParsedObject::RangeType,
+    create_seq_stmt: PgObjects::ParsedObject::Sequence,
+    create_stmt: PgObjects::ParsedObject::Table,
+    create_trig_stmt: PgObjects::ParsedObject::Trigger,
+    index_stmt: PgObjects::ParsedObject::Index,
+    rule_stmt: PgObjects::ParsedObject::Rule,
+    view_stmt: PgObjects::ParsedObject::View
+  }.freeze
+
+  DEFINE_STMT_DISPATCH = {
+    OBJECT_AGGREGATE: PgObjects::ParsedObject::Aggregate,
+    OBJECT_OPERATOR: PgObjects::ParsedObject::Operator,
+    OBJECT_TSPARSER: PgObjects::ParsedObject::TextSearchParser,
+    OBJECT_TSTEMPLATE: PgObjects::ParsedObject::TextSearchTemplate,
+    OBJECT_TYPE: PgObjects::ParsedObject::BaseType
+  }.freeze
+
+  def self.create_object(input_data)
+    new(input_data).create_object
+  end
 
-    def text_search_template?
-      try_check_get_result { stmt.define_stmt.kind == :OBJECT_TSTEMPLATE }
-    end
+  def initialize(input_data)
+    @input_data = input_data
+    @stmt = input_data.tree.stmts[0].stmt
+  end
 
-    def trigger?
-      try_check_get_result { stmt.create_trig_stmt.trigname.present? }
-    end
+  def create_object
+    determine_class.new(stmt)
+  end
 
-    def type?
-      try_check_get_result { stmt.composite_type_stmt.typevar.present? }
-    end
+  private
 
-    def view?
-      try_check_get_result { stmt.view_stmt.view.present? }
-    end
+  attr_reader :stmt, :input_data
 
-    def try_check_get_result(&)
-      result = Try(&).to_result
+  def determine_class
+    dispatch_class || raise(PgObjects::UnknownObjectTypeError, "unknown object type: #{stmt.node}")
+  end
 
-      result.success? && result.value!
+  def dispatch_class
+    case stmt.node
+    when :define_stmt
+      DEFINE_STMT_DISPATCH[stmt.define_stmt.kind]
+    when :create_table_as_stmt
+      PgObjects::ParsedObject::MaterializedView if stmt.create_table_as_stmt.objtype == :OBJECT_MATVIEW
+    else
+      DISPATCH[stmt.node]
     end
   end
 end

data/lib/pg_objects/parser.rb

@@ -1,20 +1,29 @@
+# frozen_string_literal: true
+
 require 'pg_query'
 
 ##
 # Reads directives from SQL-comments
 #
-#    --!depends_on [name_of_dependency]
+#    --!depends_on name_a
+#    --!depends_on name_a, name_b, name_c
+#    #!depends_on name_a
+#
+# The directive must start the line (no leading whitespace). Dependencies may
+# be listed on one line separated by commas and/or whitespace, or across
+# several directive lines.
 #
 # name_of_dependency: short or full name of object as well as object_name
 #
 class PgObjects::Parser
   include Import['parsed_object_factory']
-  include Memery
 
-  PG_ENTITIES = %i[operator_class trigger define_statement conversion event_trigger type function table].freeze
+  DEPENDS_ON_DIRECTIVE = /\A(?:--|#)!depends_on\s+(.+)/
 
   def load(source)
     @source = source
+    @parsed = nil
+    @parsed_object = nil
     self
   end
 
@@ -25,26 +34,33 @@ class PgObjects::Parser
   end
 
   def fetch_object_name
-    parse_query
     parsed_object.name
-  rescue PgQuery::ParseError, NoMethodError
+  rescue PgQuery::ParseError, PgObjects::UnknownObjectTypeError
     nil
   end
 
-  private
+  def fetch_qualified_object_name
+    parsed_object.qualified_name
+  rescue PgQuery::ParseError, PgObjects::UnknownObjectTypeError
+    nil
+  end
 
-  attr_reader :parsed
+  private
 
-  def parse_query
-    @parsed = PgQuery.parse(@source)
+  # Parse once per loaded source; both fetch_* methods reuse the result and
+  # +load+ clears it, so a new source is always reparsed (no stale cache).
+  def parsed
+    @parsed ||= PgQuery.parse(@source)
   end
 
-  memoize
   def parsed_object
-    parsed_object_factory.create_object(parsed)
+    @parsed_object ||= parsed_object_factory.create_object(parsed)
   end
 
   def fetch_dependencies
-    @source.split("\n").grep(/^(--|#)!/).map { |ln| ln.split[1] if ln =~ /!depends_on/ }.compact
+    @source.each_line.flat_map do |line|
+      match = DEPENDS_ON_DIRECTIVE.match(line)
+      match ? match[1].split(/[\s,]+/).reject(&:empty?) : []
+    end
   end
 end

data/lib/pg_objects/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # Brings rake tasks to rails app
 class PgObjects::Railtie < Rails::Railtie

data/lib/pg_objects/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PgObjects
-  VERSION = '1.4.8'.freeze
+  VERSION = '1.5.0'
 end

data/lib/pg_objects/yaml_configurable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # A module that provides a method to load configuration settings from a YAML file.
 module YamlConfigurable
   # Loads configuration settings from a YAML file.
@@ -6,17 +8,33 @@ module YamlConfigurable
   def load_from_yaml(file_path)
     return unless File.exist?(file_path)
 
-    config_hash = YAML.load_file(file_path)
-
-    set_if_present(config, :before_path, config_hash.dig('directories', 'before'))
-    set_if_present(config, :after_path, config_hash.dig('directories', 'after'))
-    set_if_present(config, :extensions, config_hash['extensions'])
-    set_if_present(config, :silent, config_hash['silent'])
+    settings_from(YAML.load_file(file_path)).each do |key, value|
+      set_if_present(config, key, value)
+    end
+  rescue Psych::SyntaxError => e
+    warn "[pg_objects] Ignoring malformed YAML config #{file_path}: #{e.message}"
   end
 
   private
 
+  # Maps configuration keys to their values in the parsed YAML hash.
+  def settings_from(config_hash)
+    {
+      before_path: config_hash.dig('directories', 'before'),
+      after_path: config_hash.dig('directories', 'after'),
+      extensions: config_hash['extensions'],
+      silent: config_hash['silent'],
+      transactional: config_hash['transactional'],
+      auto_hook_migrations: config_hash['auto_hook_migrations']
+    }
+  end
+
+  # Applies the value unless it is nil or an empty string/array. Booleans
+  # (including +false+) have no +empty?+ and are always applied.
   def set_if_present(config, key, value)
-    config.public_send("#{key}=", value) if value.present?
+    return if value.nil?
+    return if value.respond_to?(:empty?) && value.empty?
+
+    config.public_send("#{key}=", value)
   end
 end

data/lib/pg_objects.rb

@@ -1,10 +1,61 @@
+# frozen_string_literal: true
+
 require_relative 'pg_objects/version'
 
 module PgObjects
-  class AmbiguousDependencyError < StandardError; end
-  class CyclicDependencyError < StandardError; end
-  class DependencyNotExistError < StandardError; end
+  # Raised when a dependency name resolves to more than one object. Carries
+  # the matching objects' file paths via +candidates+ and the file that
+  # declared the dependency via +referrer+; the message lists them all. Also
+  # accepts a bare name for compatibility.
+  class AmbiguousDependencyError < StandardError
+    attr_reader :candidates, :referrer
+
+    def initialize(dep_name = nil, candidates: [], referrer: nil)
+      @candidates = candidates
+      @referrer = referrer
+      message = build_message(dep_name)
+      message.empty? ? super() : super(message)
+    end
+
+    private
+
+    def build_message(dep_name)
+      message = dep_name.to_s
+      message += " (referenced by #{referrer})" if referrer
+      message += " matches: #{candidates.join(', ')}" unless candidates.empty?
+      message
+    end
+  end
+
+  # Raised when object dependencies form a cycle. Carries the resolution chain
+  # that closed the cycle (e.g. ["a", "b", "a"]) via +cycle_path+; the message
+  # renders it as "a -> b -> a". Also accepts a single name for compatibility.
+  class CyclicDependencyError < StandardError
+    attr_reader :cycle_path
+
+    def initialize(cycle_path = nil)
+      @cycle_path = Array(cycle_path)
+      @cycle_path.empty? ? super() : super(@cycle_path.join(' -> '))
+    end
+  end
+
+  # Raised when a declared dependency matches no loaded object. Carries the
+  # file that declared the dependency via +referrer+ and includes it in the
+  # message. Also accepts a bare name for compatibility.
+  class DependencyNotExistError < StandardError
+    attr_reader :referrer
+
+    def initialize(dep_name = nil, referrer: nil)
+      @referrer = referrer
+      message = dep_name.to_s
+      message += " (referenced by #{referrer})" unless referrer.to_s.empty?
+      message.empty? ? super() : super(message)
+    end
+  end
+
   class UnsupportedAdapterError < StandardError; end
+  class UnknownObjectTypeError < StandardError; end
+  class MalformedStatementError < StandardError; end
 end
 
 require 'pg_objects/railtie' if defined?(Rails)
@@ -12,7 +63,6 @@ require 'pg_objects/railtie' if defined?(Rails)
 require 'dry-configurable'
 require 'dry-container'
 require 'dry-auto_inject'
-require 'dry/monads'
 require 'memery'
 
 require 'pg_objects/container'

data/lib/tasks/pg_objects_tasks.rake

@@ -1,23 +1,48 @@
+# frozen_string_literal: true
+
+# Resolves the connection to run against. Set PG_OBJECTS_CONNECTION_CLASS to
+# the name of an Active Record class (e.g. "AnimalsRecord") to target that
+# class's database in a multi-DB setup; unset, the global connection is used.
+pg_objects_connection = lambda do
+  class_name = ENV.fetch('PG_OBJECTS_CONNECTION_CLASS', nil)
+  next nil if class_name.nil? || class_name.strip.empty?
+
+  begin
+    Object.const_get(class_name).connection
+  rescue NameError
+    raise ArgumentError, "PG_OBJECTS_CONNECTION_CLASS is set to unknown class #{class_name.inspect}"
+  end
+end
+
 namespace :db do
   namespace :create_objects do
     desc 'Create all the database objects from "before" folder'
     task before: :environment do
-      PgObjects::Manager.new.load_files(:before).create_objects
+      PgObjects::Manager.new(connection: pg_objects_connection.call).load_files(:before).create_objects
     end
 
     desc 'Create all the database objects from "after" folder'
     task after: :environment do
-      PgObjects::Manager.new.load_files(:after).create_objects
+      PgObjects::Manager.new(connection: pg_objects_connection.call).load_files(:after).create_objects
     end
   end
 end
 
 require 'rake/hooks'
 
-before 'db:migrate' do
-  Rake::Task['db:create_objects:before'].invoke
-end
-
-after 'db:migrate' do
-  Rake::Task['db:create_objects:after'].invoke
+# Attach object-creation hooks to the tasks configured in
+# PgObjects::Config.config.hook_tasks (override in an initializer to opt out).
+# Each stage (:before/:after) maps to both the rake-hooks DSL method and the
+# matching db:create_objects:<stage> task. Set config.auto_hook_migrations to
+# false to install no hooks at all.
+if PgObjects::Config.config.auto_hook_migrations
+  PgObjects::Config.config.hook_tasks.each do |task_name, stages|
+    stages.each do |stage|
+      send(stage, task_name) do
+        task = Rake::Task["db:create_objects:#{stage}"]
+        task.reenable # allow the hook to run again within composed/repeated task runs
+        task.invoke
+      end
+    end
+  end
 end

data/pg_objects.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
@@ -12,11 +14,12 @@ Gem::Specification.new do |spec|
   spec.summary       = %q(Simple manager for PostgreSQL objects like triggers and functions)
   spec.homepage      = 'https://github.com/marinazzio/pg_objects'
 
-  spec.required_ruby_version = '>= 3.2.0'
+  spec.required_ruby_version = '>= 3.3.0'
 
   spec.metadata = {
     'allowed_push_host' => 'https://rubygems.org',
     'bug_tracker_uri' => 'https://github.com/marinazzio/pg_objects/issues',
+    'changelog_uri' => 'https://github.com/marinazzio/pg_objects/blob/master/CHANGELOG.md',
     'documentation_uri' => 'https://github.com/marinazzio/pg_objects/blob/master/README.md',
     'homepage_uri' => 'https://github.com/marinazzio/pg_objects',
     'rubygems_mfa_required' => 'true',
@@ -46,8 +49,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activerecord', '>= 6.1.7.0', '< 9'
   spec.add_dependency 'dry-auto_inject', '~> 1'
   spec.add_dependency 'dry-configurable', '~> 1'
-  spec.add_dependency 'dry-container', '0.11.0'
-  spec.add_dependency 'dry-monads', '~> 1.6'
+  spec.add_dependency 'dry-container', '~> 0.11'
   spec.add_dependency 'memery', '>= 1.5', '< 1.9'
   spec.add_dependency 'pg_query', '>= 5', '< 7'
   spec.add_dependency 'railties', '>= 4', '< 9'