sequel-annotate 1.2.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 112ffb3483f88eacd72945f7890fac2d21b8cfa8f4559b13210eb76d80e36e53
-  data.tar.gz: b2a580e9ddc239a8d2fb948ac5c571733915d9badf2c84385f3d21aaede7ab71
+  metadata.gz: 42122bfc730bb5345c90160c5a17b0861c3a5a8308dfc6a008c1fccc0b73fe3e
+  data.tar.gz: 7bbb33c84261d97a66c17b942c19fc0b432d4029b8e384f148ec79ddf96c196e
 SHA512:
-  metadata.gz: edcaf9424b611f0ec0b08fb511ef2f7f9d245756040e8adf829101264846c0768f24e4d52d143d64fed4e8a05d58aa820758023e6f1d49e83ed0b87e64c0aa70
-  data.tar.gz: 267dbf8b5693e541abbe3d97154adddfd839d2ea0e3e88475146c0d4739b6f1b42cfd2d01959984d8d7a68851375875a0e11ec28fbf1d5ab8b5c942f2d9f9efd
+  metadata.gz: 4ee1e34b6317be4e57f113a33e47c83190157ee3cbbae9cfd209c8806895aacc5e44604bbf2f0cfcbee1114a8822ed0c36a9ccdad628cb66daab58873d9020b8
+  data.tar.gz: d27e5074fb1c7642993647185605d0d714482d1f9ce5bc9e7b58817872f69674d0e803fa68210d0d73b2c176a479a44224a3678c602b1681116acae8dbf16d8c

data/CHANGELOG

@@ -1,3 +1,39 @@
+=== 1.6.0 (2020-10-05)
+
+* Add support for :namespace=>true option to attempt to automatically determine namespace (adam12) (#20)
+
+* Skip models that select from a subquery (adam12, jeremyevans) (#17)
+
+* Allow files to be skipped with sequel-annotate: false magic comment (adam12) (#18)
+
+* Ignore opening of singleton classes with class << when looking for models (adam12) (#16)
+
+=== 1.5.0 (2020-05-04)
+
+* Add support for magic comments in model files when using the :position=>:before option (qortex, jeremyevans) (#15)
+
+* Add support for PostgreSQL column comments (rgalanakis, jeremyevans) (#14)
+
+* Respect domain types on PostgreSQL (chanks) (#13)
+
+* Make schema comments handle table names that aren't just symbols (chanks) (#12)
+
+=== 1.4.0 (2018-11-15)
+
+* Support adding borders to the beginning and end of comments via :border option (kreynolds) (#9)
+
+* Support excluding indexes, constraints, and triggers from annotation via options (kreynolds) (#9)
+
+=== 1.3.1 (2018-09-27)
+
+* Make sure all annotation lines are commented by handling newlines inside annotations (jeremyevans)
+
+=== 1.3.0 (2018-07-17)
+
+* Support :namespace option to specify namespace to add for models nested in namespaces (jeremyevans)
+
+* Make Sequel::Annotate.annotate support STI classes and custom abstract base classes (a0s) (#7)
+
 === 1.2.0 (2018-04-02)
 
 * Handle PostgreSQL 10+ identity columns when running on Sequel 5.7+ (jeremyevans)

data/README.rdoc

@@ -5,7 +5,7 @@ default, it includes information on columns, indexes, and foreign key
 constraints for the current table.
 
 On PostgreSQL, this includes more advanced information, including
-check constraints, triggers, and foreign keys constraints for other
+check constraints, triggers, comments, and foreign keys constraints for other
 tables that reference the current table.
 
 == Example
@@ -72,16 +72,54 @@ or
   sa = Sequel::Annotate.new(Item)
   sa.annotate('models/item.rb', position: :before)
 
+If your models are nested in a namespace:
+
+  module ModelNamespace
+    class Item < Sequel::Model
+    end
+  end
+
+Then you can use the +:namespace+ option to set the namespace to use:
+
+  Sequel::Annotate.annotate(Dir['models/*.rb'], namespace: 'ModelNamespace')
+
+For PostgreSQL, you can optionally leave out indexes, foreign_keys, references,
+triggers, comments, and constraints by passing in false as a parameter as follows:
+
+  Sequel::Annotate.annotate(Dir['models/*.rb'], foreign_keys: false,
+                            :indexes: false, constraints: false, comments: false)
+
+The columns section can have a border on the top and bottom for easier visual distinction by setting the :border option to true
+
+  Sequel::Annotate.annotate(Dir['models/*.rb'], border: true)
+
+Models that use datasets that select from subqueries are automatically skipped,
+as annotations don't really make sense for them since they are not backed by a
+table.  You can skip other models by using a <tt># sequel-annotate: false</tt>
+magic comment somewhere in the file.
+
 === Rake Task
 
 Here's an example rake task for sequel-annotate:
 
   desc "Update model annotations"
   task :annotate do
+    # Load the models first
+    Dir['models/*.rb'].each{|f| require_relative f}
+
     require 'sequel/annotate'
     Sequel::Annotate.annotate(Dir['models/*.rb'])
   end
 
+== Running Tests
+
+Tests of sequel-annotate itself can be run with rake:
+
+  rake
+
+Set the SEQUEL_ANNOTATE_SPEC_POSTGRES_URL environment variable or appropriate
+libpq environment variables to specify which PostgreSQL database to connect to.
+
 == License
 
 MIT

data/Rakefile

@@ -28,19 +28,11 @@ begin
 rescue Gem::LoadError
 end
 
-rdoc_task_class = begin
-  require "rdoc/task"
-  RDoc::Task
-rescue LoadError
-  require "rake/rdoctask"
-  Rake::RDocTask
-end
-
 RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
 
-rdoc_task_class.new do |rdoc|
+require "rdoc/task"
+RDoc::Task.new do |rdoc|
   rdoc.rdoc_dir = "rdoc"
   rdoc.options += RDOC_OPTS
   rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb"
 end
-

data/lib/sequel/annotate.rb

@@ -10,9 +10,29 @@ module Sequel
     #   Sequel::Annotate.annotate(Dir['models/*.rb'])
     def self.annotate(paths, options = {})
       Sequel.extension :inflector
+      namespace = options[:namespace]
+
       paths.each do |path|
-        if match = File.read(path).match(/class (\S+)\s*<\s*Sequel::Model/)
-          new(match[1].constantize).annotate(path, options)
+        text = File.read(path)
+
+        next if text.match(/^#\s+sequel-annotate:\s+false$/i)
+
+        name = nil
+        if namespace == true
+          constants = text.scan(/\bmodule ([^\s]+)|class ([^\s<]+)\s*</).flatten.compact
+          name = constants.join("::") if constants.any?
+        elsif match = text.match(/class ([^\s<]+)\s*</)
+          name = match[1]
+          if namespace
+            name = "#{namespace}::#{name}"
+          end
+        end
+
+        if name
+          klass = name.constantize
+          if klass.ancestors.include?(Sequel::Model)
+            new(klass).annotate(path, options)
+          end
         end
       end
     end
@@ -28,11 +48,18 @@ module Sequel
     # Append the schema comment (or replace it if one already exists) to
     # the file at the given path.
     def annotate(path, options = {})
+      return if skip_model?
+
       orig = current = File.read(path).rstrip
 
       if options[:position] == :before
+        if current =~ /\A((?:^\s*$|^#\s*(?:frozen_string_literal|coding|encoding|warn_indent|warn_past_scope)[^\n]*\s*)*)/m
+          magic_comments = $1
+          current.slice!(0, magic_comments.length)
+        end
+
         current = current.gsub(/\A#\sTable[^\n\r]+\r?\n(?:#[^\n\r]*\r?\n)*/m, '').lstrip
-        current = "#{schema_comment}#{$/}#{$/}#{current}"
+        current = "#{magic_comments}#{schema_comment(options)}#{$/}#{$/}#{current}"
       else
         if m = current.reverse.match(/#{"#{$/}# Table: ".reverse}/m)
           offset = current.length - m.end(0) + 1
@@ -43,7 +70,7 @@ module Sequel
             current = current[0...offset].rstrip
           end
         end
-        current += "#{$/}#{$/}#{schema_comment}"
+        current += "#{$/}#{$/}#{schema_comment(options)}"
       end
 
       if orig != current
@@ -58,17 +85,38 @@ module Sequel
     # key constraints in this table referencing other tables.
     # On PostgreSQL, also includes check constraints, triggers,
     # and foreign key constraints in other tables referencing this table.
-    def schema_comment
+    #
+    # Options:
+    # :border :: Include a border above and below the comment.
+    # :indexes :: Do not include indexes in annotation if set to +false+.
+    # :foreign_keys :: Do not include foreign key constraints in annotation if set to +false+.
+    #
+    # PostgreSQL-specific options:
+    # :constraints :: Do not include check constraints if set to +false+.
+    # :references :: Do not include foreign key constraints in other tables referencing
+    #                this table if set to +false+.
+    # :triggers :: Do not include triggers in annotation if set to +false+.
+    def schema_comment(options = {})
+      return "" if skip_model?
+
       output = []
-      output << "# Table: #{model.table_name}"
+      output << "# Table: #{model.dataset.with_quote_identifiers(false).literal(model.table_name)}"
 
       meth = :"_schema_comment_#{model.db.database_type}"
       if respond_to?(meth, true)
-        send(meth, output)
+        send(meth, output, options)
       else
         schema_comment_columns(output)
-        schema_comment_indexes(output)
-        schema_comment_foreign_keys(output)
+        schema_comment_indexes(output) unless options[:indexes] == false
+        schema_comment_foreign_keys(output) unless options[:foreign_keys] == false
+      end
+
+
+      # Add beginning and end to the table if specified
+      if options[:border]
+        border = "# #{'-' * (output.map(&:size).max - 2)}"
+        output.push(border)
+        output.insert(1, border)
       end
 
       output.join($/)
@@ -87,105 +135,138 @@ module Sequel
 
       cols.times do |i|
         rows.each do |r|
-          lengths[i] = r[i].length if r[i].length > lengths[i]
+          lengths[i] = r[i].length if r[i] && r[i].length > lengths[i]
         end
       end
 
       rows.map do |r|
-        "#  #{r.zip(lengths).map{|c, l| c.ljust(l)}.join(' | ')}".strip
+        "#  #{r.zip(lengths).map{|c, l| c.to_s.ljust(l).gsub("\n", "\n#    ")}.join(' | ')}".strip
       end
     end
 
     # Use the standard columns schema output, but use PostgreSQL specific
     # code for additional schema information.
-    def _schema_comment_postgres(output)
-      schema_comment_columns(output)
+    def _schema_comment_postgres(output, options = {})
+      schema_comment_columns(output, options)
       oid = model.db.send(:regclass_oid, model.table_name)
 
       # These queries below are all based on the queries that psql
       # uses, captured using the -E option to psql.
 
-      rows = model.db.fetch(<<SQL, :oid=>oid).all
+      unless options[:indexes] == false
+        rows = model.db.fetch(<<SQL, :oid=>oid).all
 SELECT c2.relname, i.indisprimary, i.indisunique, pg_catalog.pg_get_indexdef(i.indexrelid, 0, true)
 FROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index i
   LEFT JOIN pg_catalog.pg_constraint con ON (conrelid = i.indrelid AND conindid = i.indexrelid AND contype IN ('p','u','x'))
 WHERE c.oid = :oid AND c.oid = i.indrelid AND i.indexrelid = c2.oid AND indisvalid
 ORDER BY i.indisprimary DESC, i.indisunique DESC, c2.relname;
 SQL
-      unless rows.empty?
-        output << "# Indexes:"
-        rows = rows.map do |r|
-          [r[:relname], "#{"PRIMARY KEY " if r[:indisprimary]}#{"UNIQUE " if r[:indisunique] && !r[:indisprimary]}#{r[:pg_get_indexdef].match(/USING (.+)\z/m)[1]}"]
+        unless rows.empty?
+          output << "# Indexes:"
+          rows = rows.map do |r|
+            [r[:relname], "#{"PRIMARY KEY " if r[:indisprimary]}#{"UNIQUE " if r[:indisunique] && !r[:indisprimary]}#{r[:pg_get_indexdef].match(/USING (.+)\z/m)[1]}"]
+          end
+          output.concat(align(rows))
         end
-        output.concat(align(rows))
       end
 
-      rows = model.db.fetch(<<SQL, :oid=>oid).all
+      unless options[:constraints] == false
+        rows = model.db.fetch(<<SQL, :oid=>oid).all
 SELECT r.conname, pg_catalog.pg_get_constraintdef(r.oid, true)
 FROM pg_catalog.pg_constraint r
 WHERE r.conrelid = :oid AND r.contype = 'c'
 ORDER BY 1;
 SQL
-      unless rows.empty?
-        output << "# Check constraints:"
-        rows = rows.map do |r|
-          [r[:conname], r[:pg_get_constraintdef].match(/CHECK (.+)\z/m)[1]]
+        unless rows.empty?
+          output << "# Check constraints:"
+          rows = rows.map do |r|
+            [r[:conname], r[:pg_get_constraintdef].match(/CHECK (.+)\z/m)[1]]
+          end
+          output.concat(align(rows))
         end
-        output.concat(align(rows))
       end
 
-      rows = model.db.fetch(<<SQL, :oid=>oid).all
+      unless options[:foreign_keys] == false
+        rows = model.db.fetch(<<SQL, :oid=>oid).all
 SELECT conname,
   pg_catalog.pg_get_constraintdef(r.oid, true) as condef
 FROM pg_catalog.pg_constraint r
 WHERE r.conrelid = :oid AND r.contype = 'f' ORDER BY 1;
 SQL
-      unless rows.empty?
-        output << "# Foreign key constraints:"
-        rows = rows.map do |r|
-          [r[:conname], r[:condef].match(/FOREIGN KEY (.+)\z/m)[1]]
+        unless rows.empty?
+          output << "# Foreign key constraints:"
+          rows = rows.map do |r|
+            [r[:conname], r[:condef].match(/FOREIGN KEY (.+)\z/m)[1]]
+          end
+          output.concat(align(rows))
         end
-        output.concat(align(rows))
       end
 
-      rows = model.db.fetch(<<SQL, :oid=>oid).all
+      unless options[:references] == false
+        rows = model.db.fetch(<<SQL, :oid=>oid).all
 SELECT conname, conrelid::pg_catalog.regclass,
   pg_catalog.pg_get_constraintdef(c.oid, true) as condef
 FROM pg_catalog.pg_constraint c
 WHERE c.confrelid = :oid AND c.contype = 'f' ORDER BY 2, 1;
 SQL
-      unless rows.empty?
-        output << "# Referenced By:"
-        rows = rows.map do |r|
-          [r[:conrelid], r[:conname], r[:condef].match(/FOREIGN KEY (.+)\z/m)[1]]
+        unless rows.empty?
+          output << "# Referenced By:"
+          rows = rows.map do |r|
+            [r[:conrelid], r[:conname], r[:condef].match(/FOREIGN KEY (.+)\z/m)[1]]
+          end
+          output.concat(align(rows))
         end
-        output.concat(align(rows))
       end
 
-      rows = model.db.fetch(<<SQL, :oid=>oid).all
+      unless options[:triggers] == false
+        rows = model.db.fetch(<<SQL, :oid=>oid).all
 SELECT t.tgname, pg_catalog.pg_get_triggerdef(t.oid, true), t.tgenabled, t.tgisinternal
 FROM pg_catalog.pg_trigger t
 WHERE t.tgrelid = :oid AND (NOT t.tgisinternal OR (t.tgisinternal AND t.tgenabled = 'D'))
 ORDER BY 1;
 SQL
-      unless rows.empty?
-        output << "# Triggers:"
-        rows = rows.map do |r|
-          [r[:tgname], r[:pg_get_triggerdef].match(/((?:BEFORE|AFTER) .+)\z/m)[1]]
+        unless rows.empty?
+          output << "# Triggers:"
+          rows = rows.map do |r|
+            [r[:tgname], r[:pg_get_triggerdef].match(/((?:BEFORE|AFTER) .+)\z/m)[1]]
+          end
+          output.concat(align(rows))
         end
-        output.concat(align(rows))
       end
     end
 
+    def _column_comments_postgres
+      model.db.fetch(<<SQL, :oid=>model.db.send(:regclass_oid, model.table_name)).to_hash(:attname, :description)
+SELECT a.attname, d.description
+FROM pg_description d
+JOIN pg_attribute a ON (d.objoid = a.attrelid AND d.objsubid = a.attnum)
+WHERE d.objoid = :oid AND COALESCE(d.description, '') != '';
+SQL
+    end
+
     # The standard column schema information to output.
-    def schema_comment_columns(output)
+    def schema_comment_columns(output, options = {})
       if cpk = model.primary_key.is_a?(Array)
         output << "# Primary Key: (#{model.primary_key.join(', ')})"
       end
       output << "# Columns:"
+
+      meth = :"_column_comments_#{model.db.database_type}"
+      column_comments = if options[:comments] != false && respond_to?(meth, true)
+        send(meth)
+      else
+        {}
+      end
+
       rows = model.columns.map do |col|
         sch = model.db_schema[col]
-        [col.to_s, sch[:db_type], "#{"PRIMARY KEY #{"AUTOINCREMENT " if sch[:auto_increment] && model.db.database_type != :postgres}" if sch[:primary_key] && !cpk}#{"NOT NULL " if sch[:allow_null] == false && !sch[:primary_key]}#{"DEFAULT #{sch[:default]}" if sch[:default]}#{"GENERATED BY DEFAULT AS IDENTITY" if sch[:auto_increment] && !sch[:default] && model.db.database_type == :postgres && model.db.server_version >= 100000}"]
+        parts = [
+          col.to_s,
+          sch[:db_domain_type] || sch[:db_type],
+          "#{"PRIMARY KEY #{"AUTOINCREMENT " if sch[:auto_increment] && model.db.database_type != :postgres}" if sch[:primary_key] && !cpk}#{"NOT NULL " if sch[:allow_null] == false && !sch[:primary_key]}#{"DEFAULT #{sch[:default]}" if sch[:default]}#{"GENERATED BY DEFAULT AS IDENTITY" if sch[:auto_increment] && !sch[:default] && model.db.database_type == :postgres && model.db.server_version >= 100000}",
+        ]
+        parts << (column_comments[col.to_s] || '') unless column_comments.empty?
+        parts
       end
       output.concat(align(rows))
     end
@@ -211,5 +292,13 @@ SQL
         output.concat(align(rows).sort)
       end
     end
+
+    # Whether we should skip annotations for the model.
+    # True if the model selects from a dataset.
+    def skip_model?
+      model.dataset.joined_dataset? || model.dataset.first_source_table.is_a?(Dataset)
+    rescue Sequel::Error
+      true
+    end
   end
 end

data/spec/annotated_after/manufacturer.rb

@@ -1,4 +1,4 @@
-class Manufacturer < Sequel::Model
+class Manufacturer < ABC
 end
 
 # Table: manufacturers

data/spec/annotated_after/scomplexdataset.rb

@@ -0,0 +1,7 @@
+dataset =
+  SDB[:items]
+    .left_join(:categories, { id: :category_id })
+    .select { Sequel[:items][:name] }
+
+class SComplexDataset < Sequel::Model(dataset)
+end

data/spec/annotated_after/sitemwithcoding.rb

@@ -0,0 +1,20 @@
+# coding: xyz
+
+class SItemWithCoding < Sequel::Model(SDB[:items])
+end
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers

data/spec/annotated_after/sitemwithencoding.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+class SItemWithEncoding < Sequel::Model(SDB[:items])
+end
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers

data/spec/annotated_after/sitemwithfrozenliteral.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class SItemWithFrozenLiteral < Sequel::Model(SDB[:items])
+end
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers

data/spec/annotated_after/sitemwithwarnindent.rb

@@ -0,0 +1,20 @@
+# warn_indent: true
+
+class SItemWithWarnIndent < Sequel::Model(SDB[:items])
+end
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers

data/spec/annotated_after/sitemwithwarnpastscope.rb

@@ -0,0 +1,21 @@
+# warn_past_scope: true
+# warn_indent: false
+# Additional comment that should stay
+class SItemWithWarnPastScope < Sequel::Model(SDB[:items])
+end
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers

data/spec/annotated_before/manufacturer.rb

@@ -8,5 +8,5 @@
 # Referenced By:
 #  items | items_manufacturer_name_fkey | (manufacturer_name, manufacturer_location) REFERENCES manufacturers(name, location)
 
-class Manufacturer < Sequel::Model
+class Manufacturer < ABC
 end

data/spec/annotated_before/scomplexdataset.rb

@@ -0,0 +1,7 @@
+dataset =
+  SDB[:items]
+    .left_join(:categories, { id: :category_id })
+    .select { Sequel[:items][:name] }
+
+class SComplexDataset < Sequel::Model(dataset)
+end

data/spec/annotated_before/sitemwithcoding.rb

@@ -0,0 +1,20 @@
+# coding: xyz
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers
+
+class SItemWithCoding < Sequel::Model(SDB[:items])
+end

data/spec/annotated_before/sitemwithencoding.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers
+
+class SItemWithEncoding < Sequel::Model(SDB[:items])
+end

data/spec/annotated_before/sitemwithfrozenliteral.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers
+
+class SItemWithFrozenLiteral < Sequel::Model(SDB[:items])
+end

data/spec/annotated_before/sitemwithwarnindent.rb

@@ -0,0 +1,20 @@
+# warn_indent: true
+
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers
+
+class SItemWithWarnIndent < Sequel::Model(SDB[:items])
+end

data/spec/annotated_before/sitemwithwarnpastscope.rb

@@ -0,0 +1,21 @@
+# warn_past_scope: true
+# warn_indent: false
+# Table: items
+# Columns:
+#  id                    | integer          | PRIMARY KEY AUTOINCREMENT
+#  category_id           | integer          | NOT NULL
+#  manufacturer_name     | varchar(50)      |
+#  manufacturer_location | varchar(255)     |
+#  in_stock              | boolean          | DEFAULT 0
+#  name                  | varchar(255)     | DEFAULT 'John'
+#  price                 | double precision | DEFAULT 0
+# Indexes:
+#  manufacturer_name | (manufacturer_name)
+#  name              | UNIQUE (manufacturer_name, manufacturer_location)
+# Foreign key constraints:
+#  (category_id) REFERENCES categories
+#  (manufacturer_name, manufacturer_location) REFERENCES manufacturers
+
+# Additional comment that should stay
+class SItemWithWarnPastScope < Sequel::Model(SDB[:items])
+end

data/spec/namespaced/itm_annotated.rb

@@ -0,0 +1,24 @@
+module ModelNamespace
+  class Itms < Model(:items); end
+end
+
+# Table: items
+# Columns:
+#  id                    | integer               | PRIMARY KEY DEFAULT nextval('items_id_seq'::regclass)
+#  category_id           | integer               | NOT NULL
+#  manufacturer_name     | character varying(50) |
+#  manufacturer_location | text                  |
+#  in_stock              | boolean               | DEFAULT false
+#  name                  | text                  | DEFAULT 'John'::text
+#  price                 | double precision      | DEFAULT 0
+# Indexes:
+#  items_pkey        | PRIMARY KEY btree (id)
+#  name              | UNIQUE btree (manufacturer_name, manufacturer_location)
+#  manufacturer_name | btree (manufacturer_name)
+# Check constraints:
+#  pos_id | (id > 0)
+# Foreign key constraints:
+#  items_category_id_fkey       | (category_id) REFERENCES categories(id)
+#  items_manufacturer_name_fkey | (manufacturer_name, manufacturer_location) REFERENCES manufacturers(name, location)
+# Triggers:
+#  valid_price | BEFORE INSERT OR UPDATE ON items FOR EACH ROW EXECUTE PROCEDURE valid_price()

data/spec/namespaced/itm_unannotated.rb

@@ -0,0 +1,3 @@
+module ModelNamespace
+  class Itms < Model(:items); end
+end

data/spec/sequel-annotate_spec.rb

@@ -1,16 +1,23 @@
 require 'rubygems'
 require 'fileutils'
 require File.join(File.dirname(File.expand_path(__FILE__)), '../lib/sequel/annotate')
-require 'minitest/autorun'
 
-pg_user = ENV['PGUSER'] || 'postgres'
-db_name = ENV['SEQUEL_ANNOTATE_DB'] || 'sequel-annotate_spec'
-system("dropdb", "-U", pg_user, db_name)
-system("createdb", "-U", pg_user, db_name)
-DB = Sequel.postgres(db_name, :user=>pg_user)
-SDB = Sequel.sqlite
+ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
+gem 'minitest'
+require 'minitest/global_expectations/autorun'
 
+DB = Sequel.connect(ENV['SEQUEL_ANNOTATE_SPEC_POSTGRES_URL'] || 'postgres:///sequel_annotate_test?user=sequel_annotate&password=sequel_annotate')
+raise "test database name doesn't end with test" unless DB.get{current_database.function} =~ /test\z/
+if defined?(JRUBY_VERSION)
+  SDB = Sequel.connect('jdbc:sqlite::memory:')
+else
+  SDB = Sequel.sqlite
+end
+
+DB.drop_function(:valid_price) rescue nil
 [DB, SDB].each do |db|
+  db.drop_table?(:newline_tests, :items, :manufacturers, :categories, :comment_tests)
+
   db.create_table :categories do
     primary_key :id
     String :name, :index=>{:unique=>true, :name=>'categories_name_key'}, :null=>false
@@ -25,7 +32,7 @@ SDB = Sequel.sqlite
   db.create_table :items do
     primary_key :id
     foreign_key :category_id, :categories, :null => false
-    foreign_key [:manufacturer_name, :manufacturer_location], :manufacturers
+    foreign_key [:manufacturer_name, :manufacturer_location], :manufacturers, :name=>:items_manufacturer_name_fkey
 
     String :manufacturer_name, :size => 50
     String :manufacturer_location
@@ -38,6 +45,12 @@ SDB = Sequel.sqlite
     index [:manufacturer_name, :manufacturer_location], :name=>:name, :unique=>true
     index [:manufacturer_name], :name=>:manufacturer_name
   end
+
+  db.create_table :newline_tests do
+    Integer :abcde_fghi_id
+    Integer :jkl_mnopqr_id
+    constraint(:valid_stuvw_xyz0, Sequel.case({{:abcde_fghi_id=>[5,6]}=>Sequel.~(:jkl_mnopqr_id=>nil)}, :jkl_mnopqr_id=>nil))
+  end
 end
 
 DB.run <<SQL
@@ -57,19 +70,61 @@ CREATE TRIGGER valid_price BEFORE INSERT OR UPDATE ON items
     FOR EACH ROW EXECUTE PROCEDURE valid_price();
 SQL
 
+DB.run "CREATE DOMAIN test_domain AS text"
+
+DB.create_table :domain_tests do
+  primary_key :id
+  test_domain :test_column
+end
+
+DB.create_table :comment_tests do
+  primary_key :id
+  String :name
+end
+
+DB.run "COMMENT ON COLUMN comment_tests.name IS 'name column comment'"
+
+Minitest.after_run do
+  DB.drop_table(:items, :manufacturers, :categories, :domain_tests, :comment_tests)
+  DB.run "DROP DOMAIN test_domain"
+  DB.drop_function(:valid_price)
+end
+
 class ::Item < Sequel::Model; end
 class ::Category < Sequel::Model; end
 class ::Manufacturer < Sequel::Model; end
+class ::DomainTest < Sequel::Model; end
+class ::CommentTest < Sequel::Model; end
 class ::SItem < Sequel::Model(SDB[:items]); end
+class ::SItemWithFrozenLiteral < Sequel::Model(SDB[:items]); end
+class ::SItemWithCoding < Sequel::Model(SDB[:items]); end
+class ::SItemWithEncoding < Sequel::Model(SDB[:items]); end
+class ::SItemWithWarnIndent < Sequel::Model(SDB[:items]); end
+class ::SItemWithWarnPastScope < Sequel::Model(SDB[:items]); end
+class ::SItemWithMagicComment < Sequel::Model(SDB[:items]); end
 class ::SCategory < Sequel::Model(SDB[:categories]); end
 class ::SManufacturer < Sequel::Model(SDB[:manufacturers]); end
+class ::NewlineTest < Sequel::Model; end
+class ::QualifiedTableNameTest < Sequel::Model(Sequel.qualify(:public, :categories)); end
+class SComplexDataset < Sequel::Model(SDB[:items].left_join(:categories, :id => :category_id).select{items[:name]}); end
 
+# Abstract Base Class
+ABC = Class.new(Sequel::Model)
+
+module ModelNamespace
+  Model = Class.new(Sequel::Model)
+  Model.def_Model(self)
+  class Itms < Model(:items); end
+end
 
 describe Sequel::Annotate do
   def fix_pg_comment(comment)
     if DB.server_version >= 100002 && (Sequel::MAJOR > 5 || (Sequel::MAJOR == 5 && Sequel::MINOR >= 7))
       comment = comment.sub(/DEFAULT nextval\('[a-z]+_id_seq'::regclass\)/, 'GENERATED BY DEFAULT AS IDENTITY')
     end
+    if DB.server_version >= 120000
+      comment = comment.gsub(/FOR EACH ROW EXECUTE PROCEDURE/, 'FOR EACH ROW EXECUTE FUNCTION')
+    end
     comment
   end
 
@@ -80,6 +135,52 @@ describe Sequel::Annotate do
     Dir['spec/tmp/*.rb'].each{|f| File.delete(f)}
   end
 
+  it "skips files with the sequel-annotate magic comment set to false" do
+    FileUtils.cp('spec/unannotated/sitemwithmagiccomment.rb', 'spec/tmp/')
+    Sequel::Annotate.annotate(['spec/tmp/sitemwithmagiccomment.rb'])
+    File.read('spec/tmp/sitemwithmagiccomment.rb').must_equal File.read('spec/unannotated/sitemwithmagiccomment.rb')
+  end
+
+  it "#schema_info should not return sections we set to false" do
+    Sequel::Annotate.new(Item).schema_comment(:indexes => false, :constraints => false, :foreign_keys => false, :triggers => false).must_equal(fix_pg_comment((<<OUTPUT).chomp))
+# Table: items
+# Columns:
+#  id                    | integer               | PRIMARY KEY DEFAULT nextval('items_id_seq'::regclass)
+#  category_id           | integer               | NOT NULL
+#  manufacturer_name     | character varying(50) |
+#  manufacturer_location | text                  |
+#  in_stock              | boolean               | DEFAULT false
+#  name                  | text                  | DEFAULT 'John'::text
+#  price                 | double precision      | DEFAULT 0
+OUTPUT
+
+    Sequel::Annotate.new(Category).schema_comment(:references => false).must_equal(fix_pg_comment((<<OUTPUT).chomp))
+# Table: categories
+# Columns:
+#  id   | integer | PRIMARY KEY DEFAULT nextval('categories_id_seq'::regclass)
+#  name | text    | NOT NULL
+# Indexes:
+#  categories_pkey     | PRIMARY KEY btree (id)
+#  categories_name_key | UNIQUE btree (name)
+OUTPUT
+  end
+
+  it "#schema_info should return a border if we want one" do
+    Sequel::Annotate.new(Item).schema_comment(:border => true, :indexes => false, :constraints => false, :foreign_keys => false, :triggers => false).gsub(/----+/, '---').must_equal(fix_pg_comment((<<OUTPUT).chomp))
+# Table: items
+# ---
+# Columns:
+#  id                    | integer               | PRIMARY KEY DEFAULT nextval('items_id_seq'::regclass)
+#  category_id           | integer               | NOT NULL
+#  manufacturer_name     | character varying(50) |
+#  manufacturer_location | text                  |
+#  in_stock              | boolean               | DEFAULT false
+#  name                  | text                  | DEFAULT 'John'::text
+#  price                 | double precision      | DEFAULT 0
+# ---
+OUTPUT
+  end
+
   it "#schema_info should return the model schema comment" do
     Sequel::Annotate.new(Item).schema_comment.must_equal(fix_pg_comment((<<OUTPUT).chomp))
 # Table: items
@@ -104,6 +205,7 @@ describe Sequel::Annotate do
 #  valid_price | BEFORE INSERT OR UPDATE ON items FOR EACH ROW EXECUTE PROCEDURE valid_price()
 OUTPUT
 
+    Sequel::Annotate.new(SComplexDataset).schema_comment.must_equal("")
     Sequel::Annotate.new(Category).schema_comment.must_equal(fix_pg_comment((<<OUTPUT).chomp))
 # Table: categories
 # Columns:
@@ -126,6 +228,19 @@ OUTPUT
 #  manufacturers_pkey | PRIMARY KEY btree (name, location)
 # Referenced By:
 #  items | items_manufacturer_name_fkey | (manufacturer_name, manufacturer_location) REFERENCES manufacturers(name, location)
+OUTPUT
+
+    Sequel::Annotate.new(NewlineTest).schema_comment.must_equal((<<OUTPUT).chomp)
+# Table: newline_tests
+# Columns:
+#  abcde_fghi_id | integer |
+#  jkl_mnopqr_id | integer |
+# Check constraints:
+#  valid_stuvw_xyz0 | (
+#    CASE
+#        WHEN abcde_fghi_id = ANY (ARRAY[5, 6]) THEN jkl_mnopqr_id IS NOT NULL
+#        ELSE jkl_mnopqr_id IS NULL
+#    END)
 OUTPUT
 
     Sequel::Annotate.new(SItem).schema_comment.must_equal((<<OUTPUT).chomp)
@@ -161,6 +276,36 @@ OUTPUT
 # Columns:
 #  name     | varchar(255) |
 #  location | varchar(255) |
+OUTPUT
+
+    Sequel::Annotate.new(QualifiedTableNameTest).schema_comment.must_equal(fix_pg_comment((<<OUTPUT).chomp))
+# Table: public.categories
+# Columns:
+#  id   | integer | PRIMARY KEY DEFAULT nextval('categories_id_seq'::regclass)
+#  name | text    | NOT NULL
+# Indexes:
+#  categories_pkey     | PRIMARY KEY btree (id)
+#  categories_name_key | UNIQUE btree (name)
+# Referenced By:
+#  items | items_category_id_fkey | (category_id) REFERENCES categories(id)
+OUTPUT
+
+    Sequel::Annotate.new(DomainTest).schema_comment.must_equal(fix_pg_comment((<<OUTPUT).chomp))
+# Table: domain_tests
+# Columns:
+#  id          | integer     | PRIMARY KEY DEFAULT nextval('categories_id_seq'::regclass)
+#  test_column | test_domain |
+# Indexes:
+#  domain_tests_pkey | PRIMARY KEY btree (id)
+OUTPUT
+
+    Sequel::Annotate.new(CommentTest).schema_comment.must_equal(fix_pg_comment((<<OUTPUT).chomp))
+# Table: comment_tests
+# Columns:
+#  id   | integer | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY |
+#  name | text    |                                              | name column comment
+# Indexes:
+#  comment_tests_pkey | PRIMARY KEY btree (id)
 OUTPUT
   end
   
@@ -168,7 +313,7 @@ OUTPUT
     it "#annotate #{desc} should annotate the file comment" do
       FileUtils.cp(Dir['spec/unannotated/*.rb'], 'spec/tmp')
 
-      [Item, Category, Manufacturer, SItem, SCategory, SManufacturer].each do |model|
+      [Item, Category, Manufacturer, SItem, SCategory, SManufacturer, SItemWithFrozenLiteral, SItemWithCoding, SItemWithEncoding, SItemWithWarnIndent, SItemWithWarnPastScope, SComplexDataset].each do |model|
         filename = model.name.downcase
         2.times do
           Sequel::Annotate.new(model).annotate("spec/tmp/#{filename}.rb", *args)
@@ -184,7 +329,7 @@ OUTPUT
 
       2.times do
         Sequel::Annotate.annotate(Dir["spec/tmp/*.rb"], *args)
-        [Item, Category, Manufacturer, SItem, SCategory, SManufacturer].each do |model|
+        [Item, Category, Manufacturer, SItem, SCategory, SManufacturer, SItemWithFrozenLiteral, SItemWithCoding, SItemWithEncoding, SItemWithWarnIndent, SItemWithWarnPastScope, SComplexDataset].each do |model|
           filename = model.name.downcase
           expected = File.read("spec/annotated_#{pos}/#{filename}.rb")
           expected = fix_pg_comment(expected) if model.db == DB
@@ -193,4 +338,19 @@ OUTPUT
       end
     end
   end
+
+  it ".annotate #{desc} should handle :namespace option" do
+    FileUtils.cp('spec/namespaced/itm_unannotated.rb', 'spec/tmp/')
+    Sequel::Annotate.annotate(["spec/tmp/itm_unannotated.rb"], :namespace=>'ModelNamespace')
+    File.read("spec/tmp/itm_unannotated.rb").must_equal fix_pg_comment(File.read('spec/namespaced/itm_annotated.rb'))
+    Sequel::Annotate.annotate(["spec/tmp/itm_unannotated.rb"], :namespace=>'ModelNamespace', :border=>true)
+    Sequel::Annotate.annotate(["spec/tmp/itm_unannotated.rb"], :namespace=>'ModelNamespace')
+    File.read("spec/tmp/itm_unannotated.rb").must_equal fix_pg_comment(File.read('spec/namespaced/itm_annotated.rb'))
+  end
+
+  it ".annotate #{desc} should handle :namespace => true option" do
+    FileUtils.cp('spec/namespaced/itm_unannotated.rb', 'spec/tmp')
+    Sequel::Annotate.annotate(["spec/tmp/itm_unannotated.rb"], :namespace=>true)
+    File.read("spec/tmp/itm_unannotated.rb").must_equal fix_pg_comment(File.read('spec/namespaced/itm_annotated.rb'))
+  end
 end

data/spec/unannotated/manufacturer.rb

@@ -1,2 +1,2 @@
-class Manufacturer < Sequel::Model
+class Manufacturer < ABC
 end

data/spec/unannotated/not_model.rb

@@ -0,0 +1,4 @@
+class NotModel
+  class << self
+  end
+end

data/spec/unannotated/scomplexdataset.rb

@@ -0,0 +1,7 @@
+dataset =
+  SDB[:items]
+    .left_join(:categories, { id: :category_id })
+    .select { Sequel[:items][:name] }
+
+class SComplexDataset < Sequel::Model(dataset)
+end

data/spec/unannotated/sitemwithcoding.rb

@@ -0,0 +1,4 @@
+# coding: xyz
+
+class SItemWithCoding < Sequel::Model(SDB[:items])
+end

data/spec/unannotated/sitemwithencoding.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+class SItemWithEncoding < Sequel::Model(SDB[:items])
+end

data/spec/unannotated/sitemwithfrozenliteral.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SItemWithFrozenLiteral < Sequel::Model(SDB[:items])
+end

data/spec/unannotated/sitemwithmagiccomment.rb

@@ -0,0 +1,4 @@
+# sequel-annotate: false
+
+class SItemWithMagicComment < Sequel::Model(SDB[:items])
+end

data/spec/unannotated/sitemwithwarnindent.rb

@@ -0,0 +1,4 @@
+# warn_indent: true
+
+class SItemWithWarnIndent < Sequel::Model(SDB[:items])
+end

data/spec/unannotated/sitemwithwarnpastscope.rb

@@ -0,0 +1,5 @@
+# warn_past_scope: true
+# warn_indent: false
+# Additional comment that should stay
+class SItemWithWarnPastScope < Sequel::Model(SDB[:items])
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-annotate
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-02 00:00:00.000000000 Z
+date: 2020-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: minitest-global_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -72,7 +86,7 @@ description: |
   constraints for the current table.
 
   On PostgreSQL, this includes more advanced information, including
-  check constraints, triggers, and foreign keys constraints for other
+  check constraints, triggers, comments, and foreign keys constraints for other
   tables that reference the current table.
 email: code@jeremyevans.net
 executables: []
@@ -91,25 +105,50 @@ files:
 - spec/annotated_after/item.rb
 - spec/annotated_after/manufacturer.rb
 - spec/annotated_after/scategory.rb
+- spec/annotated_after/scomplexdataset.rb
 - spec/annotated_after/sitem.rb
+- spec/annotated_after/sitemwithcoding.rb
+- spec/annotated_after/sitemwithencoding.rb
+- spec/annotated_after/sitemwithfrozenliteral.rb
+- spec/annotated_after/sitemwithwarnindent.rb
+- spec/annotated_after/sitemwithwarnpastscope.rb
 - spec/annotated_after/smanufacturer.rb
 - spec/annotated_before/category.rb
 - spec/annotated_before/item.rb
 - spec/annotated_before/manufacturer.rb
 - spec/annotated_before/scategory.rb
+- spec/annotated_before/scomplexdataset.rb
 - spec/annotated_before/sitem.rb
+- spec/annotated_before/sitemwithcoding.rb
+- spec/annotated_before/sitemwithencoding.rb
+- spec/annotated_before/sitemwithfrozenliteral.rb
+- spec/annotated_before/sitemwithwarnindent.rb
+- spec/annotated_before/sitemwithwarnpastscope.rb
 - spec/annotated_before/smanufacturer.rb
+- spec/namespaced/itm_annotated.rb
+- spec/namespaced/itm_unannotated.rb
 - spec/sequel-annotate_spec.rb
 - spec/unannotated/category.rb
 - spec/unannotated/item.rb
 - spec/unannotated/manufacturer.rb
+- spec/unannotated/not_model.rb
 - spec/unannotated/scategory.rb
+- spec/unannotated/scomplexdataset.rb
 - spec/unannotated/sitem.rb
+- spec/unannotated/sitemwithcoding.rb
+- spec/unannotated/sitemwithencoding.rb
+- spec/unannotated/sitemwithfrozenliteral.rb
+- spec/unannotated/sitemwithmagiccomment.rb
+- spec/unannotated/sitemwithwarnindent.rb
+- spec/unannotated/sitemwithwarnpastscope.rb
 - spec/unannotated/smanufacturer.rb
 homepage: http://github.com/jeremyevans/sequel-annotate
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/sequel-annotate/issues
+  changelog_uri: https://github.com/jeremyevans/sequel-annotate/blob/master/CHANGELOG
+  source_code_uri: https://github.com/jeremyevans/sequel-annotate
 post_install_message: 
 rdoc_options:
 - "--quiet"
@@ -132,8 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Annotate Sequel models with schema information