pg_graph 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 123eb2c8963ee6c45420315db19a876e76e5322ca7069d74e3d50fa4792aab58
-  data.tar.gz: 5be39db46db7775b25a40b02c76c65cedb8bf365128d5c3b602c1e3ca9003552
+  metadata.gz: 3605f3dc16a65459725b3890e9dc85d4c7f4bf3fbdbf216526a12a1c843ef6f7
+  data.tar.gz: 34a6d5f23cf5914d43f53835f817aedb79f9699104c807d20d30fb9507633162
 SHA512:
-  metadata.gz: d1c6a0c25c6980031763409d6357df388db14002c6c8c49b6eb92b93ac9cf180d9cfe7eb0789b622e5f2fc078f08a603b33ccb433947d0bd5c308bf16c204a0a
-  data.tar.gz: b43cfb4089d4fcffa32f62019c256065b9f3b00c1dddb47edb3c4ca490a68dfb1495dd68fd7204e3d42051aadeca7b737652a129ef6d3bdfd84ff47a2dafa44d
+  metadata.gz: e5e870b7ecd6ec71a8c0b8e5196511963402a372374efa003c522b847ec3b92ba50904c36046451930a79f6265455f0ba33f2f65547bd6b39a79ab88dc7ba30c
+  data.tar.gz: ec4d637a227f5a94beda42b2075240e9ecc1d70af3eaf1fa3c9c9c7c4d5990f269b70751985aa17482f3210c3ffbb635ed92638f8d5b5d69906c7e57fcc9526e

data/exe/pg_graph

@@ -16,7 +16,7 @@ SPEC = %(
   ('psql') or by the Postgres library exec() call ('exec', 'sql'). It can also
   read and write Yaml data ('yaml') that is useful for exchanging data with
   other programs
-  
+
   Note that when you're loading or dumping data in one of the SQL formats,
   you're almost always better off using postgres' own tools
   (pg_dump/pg_restore/pg_sql), except in the special case when the data
@@ -44,8 +44,8 @@ SPEC = %(
     Read/write reflections in the given table. The table argument can be both a
     full UID (eg. "my_schema.my_reflections") or just a table name in the public
     schema. Default is "public.reflections". The table and schema is created
-    if not present. 
-    
+    if not present.
+
     If this option is used together with the --reflections option, the
     reflections are read from th  e given file and written back to the database.
     If both options are missing, pg_graph will look for the default table and
@@ -74,7 +74,7 @@ SPEC = %(
     extension but can also be set explicitly using the --format option. Reads
     from standard input if FILE is missing
 
-  dump! -- DATABASE 
+  dump! -- DATABASE
     Dumps data on standard output. Default is to dump the type system in yaml
     format but this can be explicitly set using the --kind and --format options
 
@@ -96,7 +96,7 @@ def load_type(timer, opts, database)
       PgMeta.new(conn)
     end
   }
-  reflector = tg.time("reflector") { 
+  reflector = tg.time("reflector") {
     table, schema = opts.reflections_table&.split(".")&.reverse
     schema ||= PgGraph::Reflector::REFLECTIONS_SCHEMA
     table ||= PgGraph::Reflector::REFLECTIONS_TABLE
@@ -115,7 +115,7 @@ def load_type(timer, opts, database)
       end
     end
   }
-      
+
   type = timer.time("type") { PgGraph::Type.new(meta, reflector, ignore: opts.ignore) }
   [conn, type]
 end
@@ -133,7 +133,7 @@ case opts.subcommand || :dump!
     if opts.format?
       format = opts.format
     else
-      format = 
+      format =
           case File.extname(file)
             when ".sql"; "sql"
             when ".yaml", ".yml"; "yaml"
@@ -143,7 +143,7 @@ case opts.subcommand || :dump!
     end
 
     case format
-      when "sql", "exec"; 
+      when "sql", "exec";
         connection = timer.time("connect") { PgConn.new(database) }
         timer.time("load file") {
           connection.exec(IO.read(file))

data/lib/pg_graph/data/data.rb

@@ -37,8 +37,8 @@ module PgGraph::Data
     # value of a field even if the field is an association
     def object() self end
 
-    def inspect(payload = inspect_inner) 
-      "#<#{self.class}:#{uid}#{payload ? " #{payload}" : ""}>" 
+    def inspect(payload = inspect_inner)
+      "#<#{self.class}:#{uid}#{payload ? " #{payload}" : ""}>"
     end
 
     def to_h() raise NotThis end
@@ -93,7 +93,7 @@ module PgGraph::Data
     end
 
     def dup() Database.new(type, to_h) end
-    
+
     # Make Database pretend it is a PgGraph::Data object
     def is_a?(klass) klass == PgGraph::Type or super end
 
@@ -115,7 +115,7 @@ module PgGraph::Data
       id.nil? ? object : object[id]
     end
 
-    def ==(other) to_h == other.to_h end 
+    def ==(other) to_h == other.to_h end
 
     alias_method :to_h, :data
 
@@ -129,12 +129,12 @@ module PgGraph::Data
       render.to_s
     end
 
-    def to_exec_sql(ids: {}, delete: :all) 
-      to_sql(format: :exec, ids: ids, delete: delete) 
+    def to_exec_sql(ids: {}, delete: :all)
+      to_sql(format: :exec, ids: ids, delete: delete)
     end
 
-    def to_psql_sql(files = [], ids: {}, delete: :all) 
-      to_sql(format: :psql, ids: ids, delete: delete, files: files) 
+    def to_psql_sql(files = [], ids: {}, delete: :all)
+      to_sql(format: :psql, ids: ids, delete: delete, files: files)
     end
 
     # :call-seq:
@@ -208,8 +208,8 @@ module PgGraph::Data
     def data() @impl.map { |k,v| [k, v.data] }.to_h end
 
     alias_method :to_h, :data
-#   def to_sql() 
-#     tables.select { |table| !table.empty? }.map(&:to_sql).join("\n") 
+#   def to_sql()
+#     tables.select { |table| !table.empty? }.map(&:to_sql).join("\n")
 #   end
     def to_yaml() @impl.map { |k,v| [k, v.to_yaml] }.to_h end
   end
@@ -245,29 +245,29 @@ module PgGraph::Data
       type.fields.each { |column|
         next if column.is_a?(PgGraph::Type::SimpleColumn)
         that_table = db[column.type.schema.name][column.type.table.name]
-        association = 
+        association =
             case column
               when PgGraph::Type::KindRecordColumn
                 KindAssociation.new(1,
-                    self, that_table, 
-                    column.this_link_column.to_sym, 
+                    self, that_table,
+                    column.this_link_column.to_sym,
                     column.that_link_column.to_sym)
               when PgGraph::Type::RecordColumn
-                Association.new(1, 
-                    self, that_table, 
-                    column.this_link_column.to_sym, 
+                Association.new(1,
+                    self, that_table,
+                    column.this_link_column.to_sym,
                     column.that_link_column.to_sym)
               when PgGraph::Type::NmTableColumn, PgGraph::Type::MmTableColumn
                 dimension = column.is_a?(PgGraph::Type::NmTableColumn) ? 2 : 3
                 nm_table = db[column.mm_table.schema.name][column.mm_table.name]
-                LinkAssociation.new(dimension, 
+                LinkAssociation.new(dimension,
                     self, that_table, nm_table,
-                    column.this_link_column.to_sym, column.this_mm_column.to_sym, 
+                    column.this_link_column.to_sym, column.this_mm_column.to_sym,
                     column.that_mm_column.to_sym, column.that_link_column.to_sym)
               when PgGraph::Type::TableColumn
-                Association.new(2, 
-                    self, that_table, 
-                    column.this_link_column.to_sym, 
+                Association.new(2,
+                    self, that_table,
+                    column.this_link_column.to_sym,
                     column.that_link_column.to_sym)
             else
               raise NotHere
@@ -284,7 +284,7 @@ module PgGraph::Data
 
     # Return record with the given ID
     def [](id) @impl[id] end
-     
+
     # True if the table contains a record with the given ID
     def id?(id) @impl.key?(id) end
 
@@ -348,7 +348,7 @@ module PgGraph::Data
       uid =~ /^(.*?)\[(\d+)\]$/
       [$1, $2.to_i]
     end
-    
+
     # Redefine GUID to include ID of record
     def guid() "#{table.guid}[#{id}]" end
 
@@ -371,7 +371,7 @@ module PgGraph::Data
       constrain columns, lambda { |h| h.key?(:id) }, "No :id field"
       @table = table # has to go before super
       super(table.type.record_type, dimension: 1)
-      @impl = columns.map { |k,v| [k, Column.new(self, k, v)] }.to_h 
+      @impl = columns.map { |k,v| [k, Column.new(self, k, v)] }.to_h
       for name, association in table.associations
         if association.is_a?(KindAssociation) #&& @impl.key?(name)
           next if !@impl.key?(name)
@@ -407,9 +407,9 @@ module PgGraph::Data
     def columns() @impl.values.select { |field| field.is_a?(Column) } end
 
     # List of columns excluding generated columns
-    def value_columns() 
+    def value_columns()
       columns.select { |column| !column.type.generated? }.uniq
-    end 
+    end
 
     # List of association objects in the record
     def associations() @impl.values.select { |field| field.is_a?(AssociationField) } end
@@ -422,7 +422,7 @@ module PgGraph::Data
 #   def data() @impl.select { |k,v| v.is_a?(Column) }.map { |k,v| [k, v.data] }.to_h end
 
     def data()
-      @impl.select { |k,v| v.is_a?(Column) || v.is_a?(KindRecordField) }.map { |k,v| [k, v.data] }.to_h 
+      @impl.select { |k,v| v.is_a?(Column) || v.is_a?(KindRecordField) }.map { |k,v| [k, v.data] }.to_h
     end
 
     alias_method :to_h, :data
@@ -516,7 +516,7 @@ module PgGraph::Data
     # Return the value of the association. This is either a Record, TableValue,
     # or MmTableValue depending on the dimension of the association
     def object()
-      @object ||= Dimension.value_class(dimension).new(table, association.get_records(record)) 
+      @object ||= Dimension.value_class(dimension).new(table, association.get_records(record))
     end
   end
 
@@ -530,7 +530,7 @@ module PgGraph::Data
       super(record, name, association)
       @column = column
     end
-      
+
     def value_type() @column.value_type end
     def value() @column.value end
     def data() @column.data end

data/lib/pg_graph/data/render.rb

@@ -85,7 +85,7 @@ module PgGraph::Data
       case format
         when :sql; to_a.join("\n")
         when :exec; to_a.join("\n")
-        when :psql; to_psql(files).map { |group| group.join("\n") }.join("\n\n") 
+        when :psql; to_psql(files).map { |group| group.join("\n") }.join("\n\n")
       end
     end
 
@@ -134,7 +134,7 @@ module PgGraph::Data
       ]
     end
 
-    def render_begin() 
+    def render_begin()
       [ "begin;" ]
     end
 
@@ -154,7 +154,7 @@ module PgGraph::Data
     end
 
     def render_deletes(kind)
-      table_uids = 
+      table_uids =
           case kind
             when :none; []
             when :touched; @tables.reject(&:empty?).map(&:uid)
@@ -177,7 +177,7 @@ module PgGraph::Data
     end
 
     def render_truncates(kind)
-      table_uids = 
+      table_uids =
           case kind
             when :none; []
             when :touched; @tables.reject(&:empty?).map(&:uid)
@@ -190,12 +190,24 @@ module PgGraph::Data
 
     def render_updates
       @update_records.map { |record|
-        "update #{record.table.uid} set " \
-            + record.value_columns
-                .select { |column| !column.type.primary_key? }
-                .map { |column| "#{column.name} = #{render_value(column)}" }
-                .join(", ") + " " \
-            + "where id = #{record.id};" 
+        # Temporary fix for the case where a kind field is updated. Kind fields
+        # are not considered value_columns (!) so kind fields are skipped in
+        # the original code below. FIXME FIXME FIXME
+        "update #{record.table.uid} set " +
+          record.to_h.keys
+            .map { |key| record[key] }
+            .reject { |column| column.type.primary_key? }
+            .map { |column|
+              "#{column.name} = #{render_value(column)}"
+            }.join(", ") + " " \
+          + "where id = #{record.id};"
+
+#       "update #{record.table.uid} set " \
+#           + record.value_columns
+#               .select { |column| !column.type.primary_key? }
+#               .map { |column| "#{column.name} = #{render_value(column)}" }
+#               .join(", ") + " " \
+#           + "where id = #{record.id};"
       }
     end
 
@@ -262,7 +274,7 @@ module PgGraph::Data
       end
     end
 
-    def render_commit() 
+    def render_commit()
       [ "commit;" ]
     end
   end

data/lib/pg_graph/data/value.rb

@@ -9,7 +9,7 @@ module PgGraph::Data
 
   # Fake class: RecordValue.new(table, records) simply returns the Record object
   class RecordValue < Value
-    def self.new(table, records) 
+    def self.new(table, records)
       constrain table, Table
       constrain records, [Record]
       records.first
@@ -50,7 +50,7 @@ module PgGraph::Data
       @impl = {}
       records.each { |record| (@impl[record.id] ||= []) << record }
     end
-    
+
     # Number of records including duplicates
     def size() records.size end
 

data/lib/pg_graph/reflector.rb

@@ -30,7 +30,7 @@ module PgGraph
     attr_reader :pluralize
 
     # RE corresponding to #match. #re always match a full UID
-    attr_reader :re 
+    attr_reader :re
 
     # Number of name components (database, schema, table, column). It can be
     # between one and four. By ordering reflections from highest to lowest
@@ -67,9 +67,9 @@ module PgGraph
     end
 
     def to_yaml
-      { 
-        match: match, this: this, that: that, multi: multi, pluralize: pluralize, 
-        default_reflection: default_reflection 
+      {
+        match: match, this: this, that: that, multi: multi, pluralize: pluralize,
+        default_reflection: default_reflection
       }
     end
 
@@ -82,8 +82,8 @@ module PgGraph
     # +hash+ has the keys :match, :this, :that, and :pluralize. The keys can
     # also be strings
     def self.load_yaml(hash)
-      Reflection.new *METHODS.map { |key| 
-        value = hash[key].nil? ? hash[key.to_s] : hash[key] 
+      Reflection.new *METHODS.map { |key|
+        value = hash[key].nil? ? hash[key.to_s] : hash[key]
         value == "nil" ? nil : value
       }
     end
@@ -117,7 +117,7 @@ module PgGraph
     def dup() Reflector.new(reflections.dup) end
 
     # Return true if the Reflector has no reflections
-    def empty?() 
+    def empty?()
       @reflection_list ? reflections.empty? : !@reflections.values.all?(:empty?)
     end
 
@@ -126,8 +126,8 @@ module PgGraph
     def add(*reflections)
       @reflection_list = nil
       # reverse makes it possible to use #insert but keep order:
-      Array(reflections).flatten.reverse.each { |reflection| 
-        @reflections[reflection.components].insert(0, reflection) 
+      Array(reflections).flatten.reverse.each { |reflection|
+        @reflections[reflection.components].insert(0, reflection)
       }
     end
 
@@ -193,14 +193,14 @@ module PgGraph
       table ||= REFLECTIONS_TABLE
       self.class.ensure_table(conn, schema, table)
       values = reflections.select { |r| !r.default_reflection }.map.with_index { |reflection, i|
-        values = "(" + Reflection::METHODS.map { |m| 
+        values = "(" + Reflection::METHODS.map { |m|
           v = reflection.send(m)
           v.nil? ? "null" : "'#{v}'"
         }.join(", ") + ", #{i})"
       }.join(",\n")
 
       conn.exec %(
-        insert into #{schema}.#{table} 
+        insert into #{schema}.#{table}
             (match, this, that, multi, pluralize, default_reflection, ordinal)
         values
           #{values}
@@ -215,14 +215,14 @@ module PgGraph
           {"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+)_kind/", "this"=>"$1", "that"=>"$$"},
           {"match"=>"/(\\w+)_by_id/", "this"=>"$1_by", "that"=>"$1_$$", pluralize: true},
           {"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| 
-          Reflection.load_yaml initializer.merge(default_reflection: true) 
+        initializers.map { |initializer|
+          Reflection.load_yaml initializer.merge(default_reflection: true)
         }
       end
     end

data/lib/pg_graph/type/read.rb

@@ -7,7 +7,7 @@ module PgGraph::Type
       # Array of [record, meta_column] tuples
       field_columns = []
       link_columns = []
-      kind_columns = [] # The link side 
+      kind_columns = [] # The link side
       id_link_columns = [] # sub tables
 
       # Temporary arrays of meta tables
@@ -21,7 +21,7 @@ module PgGraph::Type
         meta_schema.tables.values.select { |t| t.table? }.each { |meta_table| # FIXME Ignore views for now
           (meta_table.mm_table? ? mm_tables : tables) << meta_table
           table = Table.new(
-              schema, meta_table.name, 
+              schema, meta_table.name,
               mm_table: meta_table.mm_table?,
               depending_materialized_views: meta_table.depending_views.select(&:materialized?))
           record_type = RecordType.new(table)
@@ -32,7 +32,7 @@ module PgGraph::Type
             # Create basic types needed by columns
             type_name = meta_column.type
             if !schema.key?(type_name) && !catalog.key?(type_name)
-              if meta_column.array? 
+              if meta_column.array?
                 element_name = meta_column.element_type
                 dimensions = meta_column.dimensions
                 if !schema.key?(element_name) && !catalog.key?(element_name)
@@ -51,7 +51,7 @@ module PgGraph::Type
               if meta_column.name == "id"
                 id_link_columns
               elsif meta_column.name =~ /^(?:.*_)?kind$/
-                kind_columns 
+                kind_columns
               else
                 link_columns
               end
@@ -76,7 +76,7 @@ module PgGraph::Type
         next if meta_column.kind?
         type = record_type.schema[meta_column.type] || catalog[meta_column.type]
         SimpleColumn.new(
-            record_type, meta_column.name, meta_column.name, type, 
+            record_type, meta_column.name, meta_column.name, type,
             ordinal: meta_column.ordinal,
             **column_options(meta_column))
       }
@@ -104,7 +104,7 @@ module PgGraph::Type
           (reference_count[record_type] ||= {})[type] ||= 0
           reference_count[record_type][type] += 1 if reflector.multi?(this_link_column)
 
-          field = 
+          field =
               if meta_column.kind?
                 name = reflector.this(meta_column.uid) || meta_column.name
                 name = meta_column.name if record_type[name] # Check for duplicates
@@ -171,7 +171,7 @@ module PgGraph::Type
         # Create back-references
         if this_column.unique?
           RecordColumn.new(
-              that_record_type, name, nil, this_record_type, 
+              that_record_type, name, nil, this_record_type,
               this_column.that_link_column, this_column.this_link_column)
         else
           TableColumn.new(that_record_type, name, this_table.type,
@@ -237,7 +237,7 @@ module PgGraph::Type
         if table1.type.record_type.key?(column1_name)
           raise Error, "Duplicate column name in #{table1.identifier}: #{column1_name}"
         end
-          
+
         if table2.type.record_type.key?(column2_name)
           raise Error, "Duplicate column name in #{table2.identifier}: #{column2_name}"
         end

data/lib/pg_graph/type/type.rb

@@ -1,7 +1,7 @@
 
 module PgGraph::Type
   class Error < StandardError; end
-  
+
   class Node < HashTree::Set
     include Constrain
 
@@ -16,7 +16,7 @@ module PgGraph::Type
     # The full Ruby model identifier of the object within a database. It
     # corresponds to #uid
     def schema_identifier() identifier end
-    
+
     # :call-seq: initialize(database, name, attach: true)
     def initialize(parent, name, **opts)
       constrain parent, Node, NilClass
@@ -24,8 +24,8 @@ module PgGraph::Type
       super
     end
 
-    def inspect(payload = inspect_inner) 
-      "#<#{self.class}:#{name.inspect}#{payload ? " #{payload}" : ""}>" 
+    def inspect(payload = inspect_inner)
+      "#<#{self.class}:#{name.inspect}#{payload ? " #{payload}" : ""}>"
     end
 
     def inspect_inner() nil end
@@ -33,9 +33,9 @@ module PgGraph::Type
   protected
     # Nodes with nil keys are not attached. This is used in PgCatalogSchema to
     # avoid being included in the list of schemas
-    def do_attach(key, child) 
+    def do_attach(key, child)
       !key?(key) or raise PgGraph::Error, "Duplicate fields in #{self.uid}: '#{key}'"
-      super if child 
+      super if child
     end
 
     # Forward list of methods to object. The arguments should be strings or symbols
@@ -48,7 +48,7 @@ module PgGraph::Type
 
   # Included by tables, records, and fields
   module TableObject
-    # Circular definitions. Classes that include TableObject should redefine at least 
+    # Circular definitions. Classes that include TableObject should redefine at least
     # one of the methods to break the loop
     def table() record_type.table end
     def table_type() table.type end
@@ -95,7 +95,7 @@ module PgGraph::Type
       @reflector = reflector || @reflector
       case arg
         # #read_meta is a member of Database but defined in read.rb
-        when PgMeta; read_meta(arg, ignore: ignore) 
+        when PgMeta; read_meta(arg, ignore: ignore)
         when PgConn; read_meta(PgMeta.new(arg), ignore: ignore)
       end
     end
@@ -282,12 +282,12 @@ module PgGraph::Type
     end
 
     # List of postgres columns. The columns are sorted by ordinal
-    def columns() 
+    def columns()
       @columns ||= begin
         cols = fields.map { |field|
           case field
             when SimpleColumn; field
-            when KindRecordColumn; 
+            when KindRecordColumn;
               if field.kind_column&.parent
                 nil
               else
@@ -308,7 +308,7 @@ module PgGraph::Type
         cols = fields.map { |field|
           case field
             when SimpleColumn; field
-            when KindRecordColumn; 
+            when KindRecordColumn;
               if field.kind_column&.parent
                 nil
               else
@@ -324,7 +324,7 @@ module PgGraph::Type
     end
 
     # TODO: Rename #columns to #postgres_columns and #abstract_columns to #columns
-    def abstract_columns 
+    def abstract_columns
       @abstract_columns ||= fields.map { |field|
           case field
             when SimpleColumn; field
@@ -334,19 +334,19 @@ module PgGraph::Type
             nil
           end
         }.compact.sort_by(&:ordinal)
-        
+
     end
 
     # List of columns excluding generated fields
-    def value_columns() 
+    def value_columns()
       columns.select { |column| !column.generated? }
     end
 
     # True iff name if the name of a postgres column
 #   def column?(name) self[name].is_a?(SimpleColumn) end
-    def column?(name) 
+    def column?(name)
       raise "See the rename TODO above"
-      @columns_hash.key?(name) 
+      @columns_hash.key?(name)
     end
 
   end
@@ -439,7 +439,7 @@ module PgGraph::Type
     def primary_key?() @postgres_column && @primary_key end
 
     # Return true/false or nil if postgres_column is an identity column.
-    # Sub-keys are primary keys but not identity keys 
+    # Sub-keys are primary keys but not identity keys
     def identity?() @postgres_column && @identity end
 
     # Return true/false or nil
@@ -462,8 +462,8 @@ module PgGraph::Type
 
   protected
     def initialize(
-        record_type, name, postgres_column, type, 
-        primary_key: false, identity: false, 
+        record_type, name, postgres_column, type,
+        primary_key: false, identity: false,
         reference: false, kind: false,
         nullable: true, unique: false, readonly: false, generated: false)
       constrain record_type, RecordType, NilClass
@@ -531,8 +531,8 @@ module PgGraph::Type
     forward_method :kind_column, :literal?
 
     def initialize(
-        record_type, name, postgres_column, type, 
-        this_link_column, that_link_column, 
+        record_type, name, postgres_column, type,
+        this_link_column, that_link_column,
         kind_column, **opts)
       constrain kind_column, SimpleColumn
       super(record_type, name, postgres_column, type, this_link_column, that_link_column, kind: true, **opts)

data/lib/pg_graph/version.rb

@@ -1,3 +1,3 @@
 module PgGraph
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/pg_graph.rb

@@ -53,12 +53,12 @@ module PgGraph
     def self.new(arg, reflections = nil, schema = nil, ignore: [])
       constrain arg, PgMeta, PgConn
       constrain reflections, Reflector, Array, String, PgConn, NilClass
-      meta = 
+      meta =
           case arg
             when PgMeta; arg
             when PgConn; PgMeta.new(arg)
           end
-      reflector = 
+      reflector =
           case reflections
             when Reflector; reflections
             when Array; Reflector.load_yaml(reflections)
@@ -78,7 +78,7 @@ module PgGraph
       #   instantiate(hash)
       #   instantiate(yaml)
       #   instantiate(pg_conn)
-      #   
+      #
       def instantiate(arg = nil)
         constrain arg, NilClass, Hash, PgConn
         Data.new(self, arg)
@@ -94,7 +94,7 @@ module PgGraph
     #   new(type, hash = {})
     #   new(type, yaml = {})
     #   new(type, pg_conn = nil)
-    # 
+    #
     # Note that together with ::=== and Data::Database#is_a? this makes
     # Data::Database pretend it is an instance of the Data module
     def self.new(type, arg)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_graph
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-05 00:00:00.000000000 Z
+date: 2024-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: boolean