pg_objects 1.4.8 → 1.5.0

data/bin/benchmark

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
+require 'active_support/core_ext/string/inflections' # String#classify / #constantize used by the parser
 require 'pg_objects'
 require 'benchmark'
 require 'fileutils'
@@ -242,6 +244,7 @@ class PgObjectsBenchmark
     parser = PgObjects::Parser.new
     successful_parses = 0
     parse_errors = 0
+    sample_error = nil
 
     result = Benchmark.measure do
       files.each do |file|
@@ -249,8 +252,9 @@ class PgObjectsBenchmark
         begin
           parser.load(content).fetch_object_name
           successful_parses += 1
-        rescue StandardError
+        rescue StandardError => e
           parse_errors += 1
+          sample_error ||= "#{e.class}: #{e.message}"
         end
       end
     end
@@ -260,12 +264,14 @@ class PgObjectsBenchmark
       files_count: files.size,
       successful_parses: successful_parses,
       parse_errors: parse_errors,
+      sample_error: sample_error,
       throughput: files.size / result.real
     }
 
     puts "Parsed #{files.size} files in #{result.real.round(4)}s"
     puts "Successful parses: #{successful_parses}"
     puts "Parse errors: #{parse_errors}"
+    puts "  Sample error: #{sample_error}" if sample_error
     puts "Throughput: #{(files.size / result.real).round(2)} files/second"
     puts "Average time per file: #{(result.real / files.size * 1000).round(2)}ms"
     puts
@@ -308,6 +314,8 @@ class PgObjectsBenchmark
     # Test the parsing workflow without database operations
     files = Dir[File.join(@temp_dir, '**', '*.sql')]
     db_objects = []
+    workflow_errors = 0
+    sample_error = nil
 
     result = Benchmark.measure do
       files.each do |file_path|
@@ -327,18 +335,23 @@ class PgObjectsBenchmark
           dependencies: dependencies,
           content: content
         }
-      rescue StandardError
-        # Count parse errors but continue
+      rescue StandardError => e
+        workflow_errors += 1
+        sample_error ||= "#{e.class}: #{e.message}"
       end
     end
 
     @results[:full_workflow] = {
       time: result.real,
       objects_count: db_objects.size,
+      errors: workflow_errors,
+      sample_error: sample_error,
       throughput: db_objects.size / result.real
     }
 
     puts "Processed #{db_objects.size} objects in #{result.real.round(4)}s"
+    puts "Errors: #{workflow_errors}"
+    puts "  Sample error: #{sample_error}" if sample_error
     puts "Throughput: #{(db_objects.size / result.real).round(2)} objects/second"
     puts "Average time per object: #{(result.real / db_objects.size * 1000).round(2)}ms"
     puts
@@ -354,6 +367,8 @@ class PgObjectsBenchmark
     files = Dir[File.join(@temp_dir, '**', '*.sql')]
     parser = PgObjects::Parser.new
     parsed_objects = []
+    memory_errors = 0
+    sample_error = nil
 
     files.each do |file|
       content = File.read(file)
@@ -361,11 +376,15 @@ class PgObjectsBenchmark
         object_name = parser.load(content).fetch_object_name
         dependencies = parser.fetch_directives[:depends_on]
         parsed_objects << { file: file, name: object_name, deps: dependencies }
-      rescue StandardError
-        # Ignore parse errors for memory analysis
+      rescue StandardError => e
+        memory_errors += 1
+        sample_error ||= "#{e.class}: #{e.message}"
       end
     end
 
+    puts "Parse errors during memory analysis: #{memory_errors}" if memory_errors.positive?
+    puts "  Sample error: #{sample_error}" if sample_error
+
     end_memory = memory_usage
     memory_diff = end_memory - start_memory
 
@@ -386,9 +405,25 @@ class PgObjectsBenchmark
   end
 
   def memory_usage
-    `ps -o rss= -p #{Process.pid}`.to_i * 1024 # Convert KB to bytes
+    rss_from_proc_status || rss_from_ps || 0
+  end
+
+  # Linux: parse VmRSS from /proc/self/status (portable, no shell, locale-safe)
+  def rss_from_proc_status
+    return nil unless File.readable?('/proc/self/status')
+
+    kb = File.read('/proc/self/status')[/^VmRSS:\s+(\d+)\s+kB/, 1]
+    kb && (kb.to_i * 1024) # Convert KB to bytes
+  rescue StandardError
+    nil
+  end
+
+  # Portable fallback (e.g. macOS): RSS in KB via ps
+  def rss_from_ps
+    kb = `ps -o rss= -p #{Process.pid}`.strip
+    kb.empty? ? nil : kb.to_i * 1024
   rescue StandardError
-    0
+    nil
   end
 
   def format_memory(bytes)

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'pg_objects'

data/lib/generators/pg_objects/install/install_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # Creates default directories structure
 class PgObjects::InstallGenerator < Rails::Generators::Base

data/lib/pg_objects/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'yaml_configurable'
 
 module PgObjects
@@ -10,7 +12,7 @@ module PgObjects
   #     # or full
   #     config.after_path = '/var/tmp/alternate/after'
   #     config.extensions = ['sql', 'txt']
-  #     # suppress output to console
+  #     # suppress non-error output to console
   #     config.silent = true
   #   end
   class << self
@@ -32,6 +34,55 @@ module PgObjects
     setting :extensions, default: ['sql']
     setting :silent, default: false
 
-    load_from_yaml 'config/pg_objects.yml'
+    # Wraps each create_objects run in a database transaction so a failure
+    # mid-run rolls back every object created in that run. Set to false to
+    # execute statements without a wrapping transaction — required when object
+    # files contain statements PostgreSQL rejects inside a transaction block
+    # (e.g. CREATE INDEX CONCURRENTLY, VACUUM).
+    setting :transactional, default: true
+
+    # Master switch for the Rake hooks. When false, no hooks are installed and
+    # objects are created only by invoking db:create_objects:before / :after
+    # manually. Default true for backward compatibility.
+    setting :auto_hook_migrations, default: true
+
+    # Rake tasks that trigger object creation, mapped to the stages they run.
+    # +:before+ creates objects from the "before" folder ahead of the task,
+    # +:after+ creates objects from the "after" folder once the task finishes.
+    # Override (or empty) this to opt out. db:rollback is intentionally absent
+    # (a rollback should not recreate objects).
+    setting :hook_tasks, default: {
+      'db:migrate' => %i[before after],
+      'db:schema:load' => %i[after],
+      'db:migrate:redo' => %i[before after]
+    }
+
+    DEFAULT_YAML_PATH = 'config/pg_objects.yml'
+
+    class << self
+      # YAML loading is deferred to the first config access so the path is
+      # resolved against Rails.root (when available) instead of the
+      # require-time working directory — preloaders like Spring may require
+      # the gem before the process chdirs into the app root.
+      def config
+        ensure_yaml_loaded
+        super
+      end
+
+      private
+
+      def ensure_yaml_loaded
+        return if @yaml_loaded
+
+        @yaml_loaded = true
+        load_from_yaml(yaml_config_path)
+      end
+
+      def yaml_config_path
+        return DEFAULT_YAML_PATH unless defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+
+        Rails.root.join(DEFAULT_YAML_PATH).to_s
+      end
+    end
   end
 end

data/lib/pg_objects/db_object.rb

@@ -1,16 +1,20 @@
+# frozen_string_literal: true
+
 ##
 # Represents DB object as it is described in file
 #
 # [name]  name of file without extension
 # [full_name] full pathname of file
 # [object_name] name of function, trigger etc. if it was successfully parsed, otherwise - nil
+# [qualified_object_name] schema-qualified object name (+schema.name+) when a schema is
+#   present, otherwise same as object_name; nil if parsing failed
 class PgObjects::DbObject
   include Memery
 
   include Import['parser']
 
   attr_accessor :status
-  attr_reader :full_name, :object_name
+  attr_reader :full_name, :object_name, :qualified_object_name
 
   def initialize(path, status = :new, parser:)
     @full_name = path
@@ -21,6 +25,7 @@ class PgObjects::DbObject
   def create
     parser.load(sql_query)
     @object_name = parser.fetch_object_name
+    @qualified_object_name = parser.fetch_qualified_object_name
     @status = :pending
 
     self

data/lib/pg_objects/db_object_factory.rb

@@ -3,11 +3,19 @@
 ##
 # Factory for DbObject
 #
+# Each DbObject gets its own Parser instance so the parser's mutable `@source`
+# is never shared between objects. The parser class is
+# injectable so callers/tests can substitute an alternate parser.
 class PgObjects::DbObjectFactory
-  include Import['parser']
+  def initialize(parser_class: PgObjects::Parser)
+    @parser_class = parser_class
+  end
 
   def create_instance(path, status: :new)
-    db_object = PgObjects::DbObject.new(path, status, parser:)
-    db_object.create
+    PgObjects::DbObject.new(path, status, parser: parser_class.new).create
   end
+
+  private
+
+  attr_reader :parser_class
 end

data/lib/pg_objects/logger.rb

@@ -1,10 +1,41 @@
+# frozen_string_literal: true
+
 ##
-# Console output
-#
+# Console output with severity levels. Writes to the injected +stream+
+# (default +$stdout+). With +config.silent+ enabled, +info+/+warn+ messages
+# are suppressed; +error+ messages are always written.
 class PgObjects::Logger
   include Import['config']
 
+  def initialize(stream: $stdout, **deps)
+    super(**deps)
+    @stream = stream
+  end
+
+  # Backward-compatible entry point; behaves like +info+.
   def write(str)
-    puts "== #{str} ".ljust(80, '=') unless config.silent
+    log(str)
+  end
+
+  def info(str)
+    log(str)
+  end
+
+  def warn(str)
+    log("[WARN] #{str}")
+  end
+
+  def error(str)
+    log("[ERROR] #{str}", force: true)
+  end
+
+  private
+
+  attr_reader :stream
+
+  def log(str, force: false)
+    return if config.silent && !force
+
+    stream.puts "== #{str} ".ljust(80, '=')
   end
 end

data/lib/pg_objects/manager.rb

@@ -1,23 +1,39 @@
+# frozen_string_literal: true
+
 ##
 # Manages process to create objects
 #
-# Usage:
+# Usage (dependencies are auto-injected, keyword overrides optional):
 #
-#   Manager.new(config, logger).load_files(:before).create_objects
+#   Manager.new.load_files(:before).create_objects
 #
 # or
 #
-#   Manager.new(config, logger).load_files(:after).create_objects
+#   Manager.new(config: custom_config, logger: custom_logger).load_files(:after).create_objects
+#
+# Pass +connection:+ to run against a specific database connection instead of
+# the global one (Rails 6+ multi-DB):
+#
+#   Manager.new(connection: AnimalsRecord.connection).load_files(:before).create_objects
 class PgObjects::Manager
   include Import['db_object_factory', 'config', 'logger']
 
+  def initialize(connection: nil, **deps)
+    super(**deps)
+    @connection = connection
+  end
+
   ##
   # event: +:before+ or +:after+
   #
   # used to reference configuration settings +before_path+ and +after_path+
+  #
+  # Resets the object list before loading, so each call reflects only the
+  # files for the given event.
   def load_files(event)
     validate_workability
 
+    objects.clear
     dir = config.send "#{event}_path"
     Dir[File.join(dir, '**', "*.{#{config.extensions.join(',')}}")].each do |path|
       objects << db_object_factory.create_instance(path)
@@ -27,7 +43,8 @@ class PgObjects::Manager
   end
 
   def create_objects
-    objects.each { create_object(_1) }
+    build_objects_index
+    within_transaction { objects.each { |obj| create_object(obj) } }
   end
 
   def objects
@@ -36,34 +53,68 @@ class PgObjects::Manager
 
   private
 
+  def connection
+    @connection || ActiveRecord::Base.connection
+  end
+
   def validate_workability
-    raise PgObjects::UnsupportedAdapterError if ActiveRecord::Base.connection.adapter_name != 'PostgreSQL'
+    raise PgObjects::UnsupportedAdapterError if connection.adapter_name != 'PostgreSQL'
+  end
+
+  def within_transaction(&)
+    return yield unless config.transactional
+
+    connection.transaction(&)
   end
 
-  def create_object(obj)
+  def create_object(obj, stack = [])
     return if obj.status == :done
-    raise PgObjects::CyclicDependencyError, obj.name if obj.status == :processing
+    raise PgObjects::CyclicDependencyError, cycle_path(obj, stack) if obj.status == :processing
 
     obj.status = :processing
 
-    create_dependencies(obj.dependencies)
+    create_dependencies(obj, stack + [obj.name])
 
     logger.write("creating #{obj.name}")
-    ActiveRecord::Base.connection.execute(obj.sql_query)
+    connection.execute(obj.sql_query)
 
     obj.status = :done
   end
 
-  def create_dependencies(dependencies)
-    dependencies.each { |dep_name| create_object(find_object(dep_name)) }
+  def create_dependencies(obj, stack)
+    obj.dependencies.each { |dep_name| create_object(find_object(dep_name, obj), stack) }
   end
 
-  def find_object(dep_name)
-    result = objects.select { |obj| [obj.name, obj.full_name, obj.object_name].compact.include? dep_name }
+  # Resolution chain that closed the cycle: from the first occurrence of the
+  # revisited object down to the point of revisit, closed with the object
+  # itself (e.g. ["a", "b", "a"]).
+  def cycle_path(obj, stack)
+    first_seen = stack.index(obj.name)
+    (first_seen ? stack[first_seen..] : stack) + [obj.name]
+  end
 
-    raise PgObjects::AmbiguousDependencyError, dep_name if result.size > 1
-    raise PgObjects::DependencyNotExistError, dep_name if result.empty?
+  def build_objects_index
+    @objects_index = objects.each_with_object({}) do |obj, index|
+      [obj.name, obj.full_name, obj.object_name, obj.qualified_object_name].compact.uniq.each do |key|
+        (index[key] ||= []) << obj
+      end
+    end
+  end
+
+  def find_object(dep_name, referrer = nil)
+    result = @objects_index[dep_name] || []
+
+    raise ambiguous_error(dep_name, result, referrer) if result.size > 1
+    raise PgObjects::DependencyNotExistError.new(dep_name, referrer: referrer&.full_name) if result.empty?
 
     result[0]
   end
+
+  def ambiguous_error(dep_name, result, referrer)
+    PgObjects::AmbiguousDependencyError.new(
+      dep_name,
+      candidates: result.map(&:full_name),
+      referrer: referrer&.full_name
+    )
+  end
 end

data/lib/pg_objects/parsed_object/aggregate.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # AGGREGATE object representation
 #
 class PgObjects::ParsedObject::Aggregate < 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/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Base class for parsed objects
 #
@@ -10,7 +12,43 @@ class PgObjects::ParsedObject::Base
     raise NotImplementedError
   end
 
+  # Schema-qualified name (+schema.name+) when a schema is present, otherwise
+  # the same as +name+. Used to disambiguate same-named objects across schemas.
+  def qualified_name
+    schema_name = schema
+    schema_name && !schema_name.empty? ? "#{schema_name}.#{name}" : name
+  end
+
   private
 
   attr_reader :stmt
+
+  # Schema of the object, or nil when unqualified. Subclasses that carry a
+  # schema override this; the rest inherit the unqualified default.
+  def schema
+    nil
+  end
+
+  # Returns the schema element of a pg_query name list (e.g. funcname,
+  # defnames) when the name is qualified (+schema.name+), otherwise nil.
+  def qualifier(list)
+    list[-2].string.sval if list.size > 1
+  end
+
+  # Wraps name extraction so a malformed statement (nil field, empty array)
+  # surfaces an explicit error with context. Only NoMethodErrors from
+  # dereferencing nil are wrapped; genuine programming errors propagate.
+  def extract_name
+    yield
+  rescue NoMethodError => e
+    raise unless nil_dereference?(e)
+
+    raise PgObjects::MalformedStatementError, "malformed statement for #{self.class}: #{e.message}"
+  end
+
+  def nil_dereference?(error)
+    error.receiver.nil?
+  rescue ArgumentError
+    false
+  end
 end

data/lib/pg_objects/parsed_object/base_type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#
+# Base (scalar) TYPE object representation (CREATE TYPE with I/O functions or
+# a shell CREATE TYPE without attributes) — parsed as a define_stmt.
+#
+class PgObjects::ParsedObject::BaseType < PgObjects::ParsedObject::Base
+  def name
+    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/conversion.rb

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

data/lib/pg_objects/parsed_object/domain.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+#
+# DOMAIN object representation (CREATE DOMAIN)
+#
+class PgObjects::ParsedObject::Domain < PgObjects::ParsedObject::Base
+  def name
+    extract_name { stmt.create_domain_stmt.domainname.last.string.sval }
+  end
+
+  private
+
+  def schema
+    extract_name { qualifier(stmt.create_domain_stmt.domainname) }
+  end
+end

data/lib/pg_objects/parsed_object/enum_type.rb

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

data/lib/pg_objects/parsed_object/event_trigger.rb

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

data/lib/pg_objects/parsed_object/extension.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+#
+# EXTENSION object representation
+#
+class PgObjects::ParsedObject::Extension < PgObjects::ParsedObject::Base
+  def name
+    extract_name { stmt.create_extension_stmt.extname }
+  end
+end

data/lib/pg_objects/parsed_object/function.rb

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

data/lib/pg_objects/parsed_object/index.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#
+# INDEX object representation
+#
+class PgObjects::ParsedObject::Index < PgObjects::ParsedObject::Base
+  def name
+    extract_name { stmt.index_stmt.idxname }
+  end
+
+  private
+
+  # An index lives in the schema of the table it indexes.
+  def schema
+    extract_name { stmt.index_stmt.relation.schemaname }
+  end
+end

data/lib/pg_objects/parsed_object/materialized_view.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # MATERIALIZED VIEW object representation
 #
 class PgObjects::ParsedObject::MaterializedView < PgObjects::ParsedObject::Base
   def name
-    stmt.create_table_as_stmt.into.rel.relname
+    extract_name { stmt.create_table_as_stmt.into.rel.relname }
+  end
+
+  private
+
+  def schema
+    extract_name { stmt.create_table_as_stmt.into.rel.schemaname }
   end
 end

data/lib/pg_objects/parsed_object/operator.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 #
 # OPERATOR object representation
 #
 class PgObjects::ParsedObject::Operator < 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