pg_objects 1.4.7 → 1.5.0

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

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.7'.freeze
+  VERSION = '1.5.0'
 end