pg_graph 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43d525c39dae62bc1c13b2708ddfaeb1081dba754f5ec698f8611239c2231b18
-  data.tar.gz: cdbdd1b7a98e5c986bd933dd85f631eaf5d11c9668deedb2d047886cfdc01e20
+  metadata.gz: 7ca4a215150fbefc9df5e1df93c9468719b3d3edb1bbd2f1580423a4cbc57077
+  data.tar.gz: 9bb5444f261ec3bb57c86b88c016b4dc0f7c02f8818ed54016e2d60b48c0edf2
 SHA512:
-  metadata.gz: c4a94970c70daa369e5802c7e4b22a80aad249a41f91f6b3da308d372eb53567d065abdf68d390a7156721a55fc31e29622e701f7ee89b854d5284569a10ba9a
-  data.tar.gz: 3243ed336473a1409d107147f16e1bd6c634cbad5fbfe81dd35537f12c41c4ec9a49119fb10f9f0b06b8c0b9eec7f0f6b61b7b01410ec150f492f79684bd4272
+  metadata.gz: 020ad3b29309beede81e0ec7a06417aa868aa5e892c3d333d035280e3bb5ec83a08660bd21ab4cc552a5d298cf4c51213da4d29e3953932b9777cb8282b9dcce
+  data.tar.gz: 69f6c30448b6d0690d51bda338f380d351e616766f56e39c868a15ffa99413becc2022c9a30b8c2adf698b1eb79a1f7e55e555408e283696f8ebce83e25c0c24

data/exe/pg_graph

@@ -21,7 +21,7 @@ SPEC = %(
   you're almost always better off using postgres' own tools
   (pg_dump/pg_restore/pg_sql), except in the special case when the data
   contains circular foreign-key constraints and you don't have superuser
-  privileges
+  privileges (say what? FIXME)
 
   The dump command can also write the type of the database in yaml format. This
   is the default

data/lib/pg_graph/reflector.rb

@@ -14,7 +14,19 @@ module PgGraph
     # included in the model. Can be nil
     attr_reader :that
 
-    # Don't pluralize the result of #that if false. Default false
+    # True if this reflection applies to multiple references in a table
+    def multi? = multi || multi.nil?
+
+    # If true or nil, the reflection applies to multiple references in a table
+    # to the same referenced table. nil is used to mark the rule to not be
+    # included in the count of references. This is used to exclude explicit
+    # patterns like /^parent_id$/ that can co-exist with a another reference to
+    # the table
+    attr_reader :multi
+
+    # Pluralize the result of #that if true. Default nil. Note that if
+    # pluralize is nil, the Reflector will pluralize unless the column is
+    # unique
     attr_reader :pluralize
 
     # RE corresponding to #match. #re always match a full UID
@@ -30,10 +42,11 @@ module PgGraph
     attr_reader :default_reflection
 
     # +this+ and +that+ are template strings, nil, or false
-    def initialize(match, this, that, pluralize = false, default_reflection = false)
+    def initialize(match, this, that, multi = nil, pluralize = nil, default_reflection = false)
       constrain match, Regexp, String
       constrain this, String, NilClass
       constrain that, String, FalseClass, NilClass
+      constrain multi, true, false, nil
       constrain pluralize, TrueClass, FalseClass, NilClass
       constrain default_reflection, TrueClass, FalseClass, NilClass
       @match = match.is_a?(Regexp) ? match.source : match
@@ -48,12 +61,16 @@ module PgGraph
       (1..4).include?(@components) or raise "Illegal number of name components: #{@match}"
       @this = this
       @that = that
-      @pluralize = pluralize || pluralize.nil?
+      @multi = multi
+      @pluralize = pluralize
       @default_reflection = default_reflection || false
     end
 
     def to_yaml
-      { match: match, this: this, that: that, pluralize: pluralize, default_reflection: default_reflection }
+      { 
+        match: match, this: this, that: that, multi: multi, pluralize: pluralize, 
+        default_reflection: default_reflection 
+      }
     end
 
     def ==(other)
@@ -71,7 +88,7 @@ module PgGraph
       }
     end
 
-    METHODS = %w(match this that pluralize default_reflection).map(&:to_sym)
+    METHODS = %w(match this that multi pluralize default_reflection).map(&:to_sym)
   end
 
   class Reflector
@@ -123,17 +140,26 @@ module PgGraph
     end
 
     # Find 'that' field name for the given UID by searching through reflections
-    # for a match. The field name is pluralized unless +unique+ is true. The
-    # :table option can be used to override the table name in '$$' rules. This
-    # is used in N:M and M:M relations. Returns nil if no match was found or if
-    # a matching reflection has #continue equal to false
-    def that(uid, unique, table: nil)
+    # for a match. The name is pluralized if the matcher returns true or if the
+    # matcher returns nil and unique is false The :table option can be used to
+    # override the table name in '$$' rules. This is used in N:M and M:M
+    # relations. Returns nil if no match was found or if a matching reflection
+    # has #continue equal to false
+    def that(uid, unique, multi = false, table: nil)
       constrain uid, String
-      if (name, pluralize = do_match(uid, :that, table: table))
-        pluralize != false && unique ? name : PgGraph.inflector.pluralize(name)
+      if (name, pluralize = do_match(uid, :that, multi, table: table))
+        if pluralize.nil? && !unique || pluralize
+          PgGraph.inflector.pluralize(name)
+        else
+          name
+        end
       end
     end
 
+    def multi?(uid)
+      reflection = reflections.find { |reflection| reflection.re.match(uid) }&.multi == false
+    end
+
     def to_yaml
       reflections.map { |reflection| reflection.to_yaml }
     end
@@ -152,7 +178,7 @@ module PgGraph
       table ||= REFLECTIONS_TABLE
       if conn.schema.exist?(schema) && conn.schema.exist_table?(schema, table)
         yaml = conn.structs(%(
-          select match, this, that, pluralize, false as "default_reflection"
+          select match, this, that, multi, pluralize, false as "default_reflection"
           from #{schema}.#{table}
           order by ordinal
         )).map(&:to_h)
@@ -175,7 +201,7 @@ module PgGraph
 
       conn.exec %(
         insert into #{schema}.#{table} 
-            (match, this, that, pluralize, default_reflection, ordinal)
+            (match, this, that, multi, pluralize, default_reflection, ordinal)
         values
           #{values}
       )
@@ -185,13 +211,14 @@ module PgGraph
       @default_reflections ||= begin
         initializers = [
           {"match"=>"/parent_id/", "that"=>"child"},
-          {"match"=>"/child_id/", "that"=>"parent"}, 
-          {"match"=>"/parent_(\\w+)_id/", "that"=>"child_$1"}, 
-          {"match"=>"/child_(\\w+)_id/", "that"=>"parent_$1"}, 
-          {"match"=>"kind", "this"=>"kind", "that"=>"$$"}, 
+          {"match"=>"/child_id/", "that"=>"parent"},
+          {"match"=>"/parent_(\\w+)_id/", "that"=>"child_$1"},
+          {"match"=>"/child_(\\w+)_id/", "that"=>"parent_$1"},
+          {"match"=>"kind", "this"=>"kind", "that"=>"$$"},
           {"match"=>"/(\\w+)_kind/", "this"=>"$1", "that"=>"$$"}, 
           {"match"=>"/(\\w+)_by_id/", "this"=>"$1_by", "that"=>"$1_$$", pluralize: true},
-          {"match"=>"/(\\w+)_id/", "this"=>"$1", "that"=>"$$"},
+          {"match"=>"/(\\w+)_id/", "this"=>"$1", "that"=>"$$", multi: false},
+          {"match"=>"/(\\w+)_id/", "this"=>"$1", "that"=>"$1_of", multi: true, pluralize: false},
           {"match"=>"/(\\w+)/", "this"=>"$1", "that"=>"$$"}, # Kind fields w/o explicit 'kind'
         ]
         initializers.map { |initializer| 
@@ -205,9 +232,11 @@ module PgGraph
     end
 
   private
+
     # +kind+ can be :this or :that
-    def do_match(uid, kind, table: nil)
+    def do_match(uid, kind, multi = true, table: nil)
       reflections.find { |reflection|
+        next if multi == true && reflection.multi == false
         match_data = reflection.re.match(uid) or next
         template = reflection.send(kind).dup
         if template == false
@@ -230,7 +259,8 @@ module PgGraph
           match varchar not null,
           this varchar,
           that varchar not null,
-          pluralize boolean not null,
+          multi boolean,
+          pluralize boolean,
           default_reflection boolean not null,
           ordinal integer not null -- zero-based
         )

data/lib/pg_graph/version.rb

@@ -1,3 +1,3 @@
 module PgGraph
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/type/read.rb

@@ -68,9 +68,7 @@ module PgGraph::Type
         meta_table.depending_tables.each { |meta_depending_table|
           depending_table = dot(meta_depending_table.path)
           table.depending_tables << depending_table
-#         puts "#{table.uid} -> #{depending_table.uid}"
         }
-
       }
 
       # Create postgres columns except kind_columns
@@ -83,16 +81,29 @@ module PgGraph::Type
             **column_options(meta_column))
       }
 
-
-      # Create and collect forward-references. link_fields is a list of [uid, record_column] tuples
+      # link_fields is a list of [uid, record_column] tuples
       link_fields = []
+
+      # Map from referencing table to referenced table to reference. It is
+      # used to detect when the default reverse map doesn't work because of
+      # name collisions
+      reference_count = {}
+
+      # Create and collect forward-references
       (link_columns + kind_columns).each { |record_type, meta_column|
+        reference_count[record_type] ||= {}
+
         meta_column.references.each { |constraint|
           constraint.referencing_columns.size == 1 or raise Error, "Can't handle multi-column keys (for now)"
           type = dot(constraint.referenced_table.path).type.record_type
           this_link_column = constraint.referencing_columns.first.name
           that_link_column = constraint.referenced_columns.first.name
 
+          # Count references by running the reflector in the link column (this
+          # is expensive because we're doing it again later)
+          (reference_count[record_type] ||= {})[type] ||= 0
+          reference_count[record_type][type] += 1 if reflector.multi?(this_link_column)
+
           field = 
               if meta_column.kind?
                 name = reflector.this(meta_column.uid) || meta_column.name
@@ -119,10 +130,6 @@ module PgGraph::Type
         }
       }
 
-      # Detect derived tables
-#     link_fields.each { |uid, record_column|
-#       if record_column.this_link_column.primary_key? && that_link_column.primary_key?
-
       # Create back-reference fields
       (link_fields).each { |uid, this_column|
         this_record_type = this_column.record_type
@@ -135,7 +142,8 @@ module PgGraph::Type
           this_column.postgres_column == "id" or raise Error, "Primary keys should be named 'id'"
           name = this_record_type.name
         else
-          name = reflector.that(uid, this_column.unique?, table: this_record_type.name)
+          multi = reference_count[this_record_type][that_record_type] > 1
+          name = reflector.that(uid, this_column.unique?, multi, table: this_record_type.name)
           name ||= PgGraph.inflector.pluralize(this_column.table.name) if this_column.kind?
         end
 
@@ -202,8 +210,8 @@ module PgGraph::Type
         mm_column2 = constraint2.referencing_columns.first.name
         mm_column2_uid = constraint2.referencing_columns.first.uid
 
-        column1_name = reflector.that(mm_column1_uid, false, table: table2.record_type.name)
-        column2_name = reflector.that(mm_column2_uid, false, table: table1.record_type.name)
+        column1_name = reflector.that(mm_column1_uid, false, false, table: table2.record_type.name)
+        column2_name = reflector.that(mm_column2_uid, false, false, table: table1.record_type.name)
 
         # FIXME: DAGs over an super table creates problems if reflections
         # doesn't match (eg. role_id/group_id instead of

data/lib/type/type.rb

@@ -249,6 +249,7 @@ module PgGraph::Type
       end
     end
 
+    # FIXME Duplicate code
     def postgres_columns()
       @postgres_columns ||= begin
         cols = fields.map { |field|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_graph
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Claus Rasmussen