activerecord-jdbc-alt-adapter 70.0.0.rc1-java → 70.0.0.rc2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46248cf1484387bba94e6cfd944c4d81b03103b9fd075554655e71f52cc37ef2
-  data.tar.gz: 4a9592dfab799bf3093bc2b393617e67db319272703a4f985c6609add3b451a5
+  metadata.gz: 61ee665d7dfe0dc2b0a84c5c2014ba1c4427dfb63a52a0992eee1ba8449360c0
+  data.tar.gz: fdd181f5107c6af495b97f3d67bc5031fd9b9c0a9e454ea6e0fc06e280a544dd
 SHA512:
-  metadata.gz: 80e0e9e9d4934e8bb53c997dd61eb82eb77cf823177be6fa93599d459d6eeb7e8cc4591ae90b7cf794c3c21d0c4e37b4aff9528e201c611df529da6d4ac3c610
-  data.tar.gz: 5603dea7f3811d3163bc41e701487c6859885e86cc0e4b69a9b039f87def2d733b4bfb5f2a6febcd8536b1c7ef794e7bfe1683b748aab8660f8822d7fec4f825
+  metadata.gz: 16c1ca8af769eec8eaab04650e6293f0b0e8cfdc20ae77bb5c2d37c276f5104ed3e42da35a1397215f4d8925bd192e87a18c163cdbdb03578573baa181d7550b
+  data.tar.gz: e200993abec93188a25038d74a3641d83e16cd11d87b10fba1051d51e2e61622dca977edad111c965215e731f51d013bec95bdf42ef73f6c98067a118acf9117

data/.github/workflows/main.yml

@@ -0,0 +1,118 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Tests
+
+on:
+  push:
+    branches: [ stable-dev ]
+  pull_request:
+    branches: [ stable-dev ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test-rails-pgsql:
+
+    name: Rails Tests (Postgres)
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: [ 'jruby-head' ]
+        db: [ 'postgresql' ]
+        test_targets: [ "rails:test_postgresql" ]
+        ar_version: ["7-0-stable"]
+        prepared_statements: [ 'false', 'true' ]
+
+    services:
+      postgres:
+        image: postgres:10
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+    env:
+      DB: ${{ matrix.db }}
+      AR_VERSION: ${{ matrix.ar_version }}
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
+      JDBC_SQLITE_VERSION: "3.32.3.3"
+      PGHOST: localhost
+      PGPORT: 5432
+      PGUSER: postgres
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - name: Setup database
+        run: |
+          psql -c "create database activerecord_unittest;" -U postgres
+          psql -c "create database activerecord_unittest2;" -U postgres
+      - name: Build
+        run: |
+          rake jar # compiles ext generates: lib/arjdbc/jdbc/adapter_java.jar
+      - name: Run tests
+        run: |
+          bundle exec rake ${{ matrix.test_targets }}
+
+  test-arjdbc-pgsql:
+
+    name: ARJDBC Tests (Postgres)
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['jruby-head']
+        db: ['postgresql']
+        test_targets: ["db:postgresql test_postgresql"]
+        prepared_statements: ['false', 'true']
+        insert_returning: ['false', 'true']
+
+    services:
+      postgres:
+        image: postgres:10
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+    env:
+      DB: ${{ matrix.db }}
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
+      INSERT_RETURNING: ${{ matrix.insert_returning }}
+      PGHOST: localhost
+      PGPORT: 5432
+      PGUSER: postgres
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - name: Build
+        run: |
+          rake jar
+      - name: Run tests
+        run: |
+          bundle exec rake ${{ matrix.test_targets }}

data/Gemfile

@@ -55,7 +55,7 @@ group :test do
   gem 'mocha', '~> 1.2', require: false # Rails has '~> 0.14'
 
   gem 'bcrypt', '~> 3.1.11', require: false
-  gem 'jdbc-mssql', '~> 0.9.0', require: nil
+  gem 'jdbc-mssql', '~> 12.2', require: nil
   # gem 'pry-debugger-jruby', platform: :jruby
 end
 

data/README.md

@@ -30,13 +30,16 @@ Add the following to your `Gemfile`:
 ```ruby
 platforms :jruby do
   # Use jdbc as the database for Active Record
-  gem 'activerecord-jdbc-alt-adapter', '~> 60.0.0.rc1'
+  gem 'activerecord-jdbc-alt-adapter', '~> 70.0.0.rc1'
   gem 'jdbc-mssql', '~> 0.9.0'
 end
 ```
 
 Or look at the sample rails and see how is set up:
 
+
+- Rails 7.0 sample app [wombat70](https://github.com/JesseChavez/wombat70)
+
 - Rails 6.1 sample app [wombat61](https://github.com/JesseChavez/wombat61)
 
 - Rails 6.0 sample app [wombat60](https://github.com/JesseChavez/wombat60)

data/lib/arjdbc/mssql/adapter.rb

@@ -35,14 +35,15 @@ module ActiveRecord
       ADAPTER_NAME = 'MSSQL'.freeze
 
       MSSQL_VERSION_YEAR = {
-        8 => '2000',
-        9 => '2005',
+        8  => '2000',
+        9  => '2005',
         10 => '2008',
         11 => '2012',
         12 => '2014',
         13 => '2016',
         14 => '2017',
-        15 => '2019'
+        15 => '2019',
+        16 => '2022'
       }.freeze
 
       include Jdbc::ConnectionPoolCallbacks

data/lib/arjdbc/mssql/connection_methods.rb

@@ -78,12 +78,15 @@ ArJdbc::ConnectionMethods.module_eval do
       url << "sendTimeAsDatetime=#{config[:send_time_as_datetime] || false};"
       url << "loginTimeout=#{config[:login_timeout].to_i};" if config[:login_timeout]
       url << "lockTimeout=#{config[:lock_timeout].to_i};"
+      url << "encrypt=#{config[:encrypt]};" if config.key?(:encrypt)
+      url << "trustServerCertificate=#{config[:trust_server_certificate]};" if config.key?(:trust_server_certificate)
       app = config[:appname] || config[:application]
       url << "applicationName=#{app};" if app
       isc = config[:integrated_security] # Win only - needs sqljdbc_auth.dll
       url << "integratedSecurity=#{isc};" unless isc.nil?
       url
     end
+
     jdbc_connection(config)
   end
   alias_method :jdbcsqlserver_connection, :sqlserver_connection

data/lib/arjdbc/postgresql/adapter.rb

@@ -798,11 +798,96 @@ module ActiveRecord::ConnectionAdapters
 
     private
 
-    # Prepared statements aren't schema aware so we need to make sure we
-    # store different PreparedStatement objects for different schemas
+    FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:
+
+    def execute_and_clear(sql, name, binds, prepare: false, async: false)
+      sql = transform_query(sql)
+      check_if_write_query(sql)
+
+      if !prepare || without_prepared_statement?(binds)
+        result = exec_no_cache(sql, name, binds, async: async)
+      else
+        result = exec_cache(sql, name, binds, async: async)
+      end
+      begin
+        ret = yield result
+      ensure
+        # Is this really result in AR PG?
+#        result.clear
+      end
+      ret
+    end
+
+    def exec_no_cache(sql, name, binds, async: false)
+      materialize_transactions
+      mark_transaction_written_if_write(sql)
+
+      # make sure we carry over any changes to ActiveRecord.default_timezone that have been
+      # made since we established the connection
+      update_typemap_for_default_timezone
+
+      type_casted_binds = type_casted_binds(binds)
+      log(sql, name, binds, type_casted_binds, async: async) do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          @connection.exec_params(sql, type_casted_binds)
+        end
+      end
+    end
+
+    def exec_cache(sql, name, binds, async: false)
+      materialize_transactions
+      mark_transaction_written_if_write(sql)
+      update_typemap_for_default_timezone
+
+      stmt_key = prepare_statement(sql, binds)
+      type_casted_binds = type_casted_binds(binds)
+
+      log(sql, name, binds, type_casted_binds, stmt_key, async: async) do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          @connection.exec_prepared(stmt_key, type_casted_binds)
+        end
+      end
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless is_cached_plan_failure?(e)
+
+      # Nothing we can do if we are in a transaction because all commands
+      # will raise InFailedSQLTransaction
+      if in_transaction?
+        raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
+      else
+        @lock.synchronize do
+          # outside of transactions we can simply flush this query and retry
+          @statements.delete sql_key(sql)
+        end
+        retry
+      end
+    end
+
+    # Annoyingly, the code for prepared statements whose return value may
+    # have changed is FEATURE_NOT_SUPPORTED.
+    #
+    # This covers various different error types so we need to do additional
+    # work to classify the exception definitively as a
+    # ActiveRecord::PreparedStatementCacheExpired
+    #
+    # Check here for more details:
+    # https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573
+    def is_cached_plan_failure?(e)
+      pgerror = e.cause
+      pgerror.result.result_error_field(PG::PG_DIAG_SQLSTATE) == FEATURE_NOT_SUPPORTED &&
+        pgerror.result.result_error_field(PG::PG_DIAG_SOURCE_FUNCTION) == "RevalidateCachedQuery"
+    rescue
+      false
+    end
+
+    def in_transaction?
+      open_transactions > 0
+    end
+
+    # Returns the statement identifier for the client side cache
+    # of statements
     def sql_key(sql)
       "#{schema_search_path}-#{sql}"
     end
-
   end
 end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -92,7 +92,7 @@ module ArJdbc
 
       def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
         if !type_map.key?(oid)
-          load_additional_types(type_map, oid)
+          load_additional_types([oid])
         end
 
         type_map.fetch(oid, fmod, sql_type) {
@@ -103,15 +103,94 @@ module ArJdbc
         }
       end
 
+      def reload_type_map
+          type_map.clear
+          initialize_type_map
+      end
+
+        def initialize_type_map_inner(m)
+          m.register_type "int2", Type::Integer.new(limit: 2)
+          m.register_type "int4", Type::Integer.new(limit: 4)
+          m.register_type "int8", Type::Integer.new(limit: 8)
+          m.register_type "oid", OID::Oid.new
+          m.register_type "float4", Type::Float.new
+          m.alias_type "float8", "float4"
+          m.register_type "text", Type::Text.new
+          register_class_with_limit m, "varchar", Type::String
+          m.alias_type "char", "varchar"
+          m.alias_type "name", "varchar"
+          m.alias_type "bpchar", "varchar"
+          m.register_type "bool", Type::Boolean.new
+          register_class_with_limit m, "bit", OID::Bit
+          register_class_with_limit m, "varbit", OID::BitVarying
+          m.register_type "date", OID::Date.new
+
+          m.register_type "money", OID::Money.new
+          m.register_type "bytea", OID::Bytea.new
+          m.register_type "point", OID::Point.new
+          m.register_type "hstore", OID::Hstore.new
+          m.register_type "json", Type::Json.new
+          m.register_type "jsonb", OID::Jsonb.new
+          m.register_type "cidr", OID::Cidr.new
+          m.register_type "inet", OID::Inet.new
+          m.register_type "uuid", OID::Uuid.new
+          m.register_type "xml", OID::Xml.new
+          m.register_type "tsvector", OID::SpecializedString.new(:tsvector)
+          m.register_type "macaddr", OID::Macaddr.new
+          m.register_type "citext", OID::SpecializedString.new(:citext)
+          m.register_type "ltree", OID::SpecializedString.new(:ltree)
+          m.register_type "line", OID::SpecializedString.new(:line)
+          m.register_type "lseg", OID::SpecializedString.new(:lseg)
+          m.register_type "box", OID::SpecializedString.new(:box)
+          m.register_type "path", OID::SpecializedString.new(:path)
+          m.register_type "polygon", OID::SpecializedString.new(:polygon)
+          m.register_type "circle", OID::SpecializedString.new(:circle)
+          m.register_type "regproc", OID::Enum.new
+          # FIXME: adding this vector type leads to quoting not handlign Array data in quoting.
+          #m.register_type "_int4", OID::Vector.new(",", m.lookup("int4"))
+          register_class_with_precision m, "time", Type::Time
+          register_class_with_precision m, "timestamp", OID::Timestamp
+          register_class_with_precision m, "timestamptz", OID::TimestampWithTimeZone
+
+          m.register_type "numeric" do |_, fmod, sql_type|
+            precision = extract_precision(sql_type)
+            scale = extract_scale(sql_type)
+
+            # The type for the numeric depends on the width of the field,
+            # so we'll do something special here.
+            #
+            # When dealing with decimal columns:
+            #
+            # places after decimal  = fmod - 4 & 0xffff
+            # places before decimal = (fmod - 4) >> 16 & 0xffff
+            if fmod && (fmod - 4 & 0xffff).zero?
+              # FIXME: Remove this class, and the second argument to
+              # lookups on PG
+              Type::DecimalWithoutScale.new(precision: precision)
+            else
+              OID::Decimal.new(precision: precision, scale: scale)
+            end
+          end
+
+          m.register_type "interval" do |*args, sql_type|
+            precision = extract_precision(sql_type)
+            OID::Interval.new(precision: precision)
+          end
+
+          # pgjdbc returns these if the column is auto-incrmenting
+          m.alias_type 'serial', 'int4'
+          m.alias_type 'bigserial', 'int8'
+        end
+
+
+      # We differ from AR here because we will initialize type_map when adapter initializes
       def type_map
         @type_map
       end
 
-      def reload_type_map
-        if ( @type_map ||= nil )
-          @type_map.clear
-          initialize_type_map(@type_map)
-        end
+      def initialize_type_map(m = type_map)
+        initialize_type_map_inner(m)
+        load_additional_types
       end
 
       private
@@ -124,117 +203,53 @@ module ArJdbc
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:register_class_with_precision, ...)
       end
 
-      def initialize_type_map(m = type_map)
-        m.register_type "int2", Type::Integer.new(limit: 2)
-        m.register_type "int4", Type::Integer.new(limit: 4)
-        m.register_type "int8", Type::Integer.new(limit: 8)
-        m.register_type "oid", OID::Oid.new
-        m.register_type "float4", Type::Float.new
-        m.alias_type "float8", "float4"
-        m.register_type "text", Type::Text.new
-        register_class_with_limit m, "varchar", Type::String
-        m.alias_type "char", "varchar"
-        m.alias_type "name", "varchar"
-        m.alias_type "bpchar", "varchar"
-        m.register_type "bool", Type::Boolean.new
-        register_class_with_limit m, "bit", OID::Bit
-        register_class_with_limit m, "varbit", OID::BitVarying
-        m.register_type "date", OID::Date.new
-
-        m.register_type "money", OID::Money.new
-        m.register_type "bytea", OID::Bytea.new
-        m.register_type "point", OID::Point.new
-        m.register_type "hstore", OID::Hstore.new
-        m.register_type "json", Type::Json.new
-        m.register_type "jsonb", OID::Jsonb.new
-        m.register_type "cidr", OID::Cidr.new
-        m.register_type "inet", OID::Inet.new
-        m.register_type "uuid", OID::Uuid.new
-        m.register_type "xml", OID::Xml.new
-        m.register_type "tsvector", OID::SpecializedString.new(:tsvector)
-        m.register_type "macaddr", OID::Macaddr.new
-        m.register_type "citext", OID::SpecializedString.new(:citext)
-        m.register_type "ltree", OID::SpecializedString.new(:ltree)
-        m.register_type "line", OID::SpecializedString.new(:line)
-        m.register_type "lseg", OID::SpecializedString.new(:lseg)
-        m.register_type "box", OID::SpecializedString.new(:box)
-        m.register_type "path", OID::SpecializedString.new(:path)
-        m.register_type "polygon", OID::SpecializedString.new(:polygon)
-        m.register_type "circle", OID::SpecializedString.new(:circle)
-
-        register_class_with_precision m, "time", Type::Time
-        register_class_with_precision m, "timestamp", OID::Timestamp
-        register_class_with_precision m, "timestamptz", OID::TimestampWithTimeZone
-
-        m.register_type "numeric" do |_, fmod, sql_type|
-          precision = extract_precision(sql_type)
-          scale = extract_scale(sql_type)
-
-          # The type for the numeric depends on the width of the field,
-          # so we'll do something special here.
-          #
-          # When dealing with decimal columns:
-          #
-          # places after decimal  = fmod - 4 & 0xffff
-          # places before decimal = (fmod - 4) >> 16 & 0xffff
-          if fmod && (fmod - 4 & 0xffff).zero?
-            # FIXME: Remove this class, and the second argument to
-            # lookups on PG
-            Type::DecimalWithoutScale.new(precision: precision)
-          else
-            OID::Decimal.new(precision: precision, scale: scale)
+      def load_additional_types(oids = nil) # :nodoc:
+        initializer = ArjdbcTypeMapInitializer.new(type_map)
+        load_types_queries(initializer, oids) do |query|
+          execute_and_clear(query, "SCHEMA", []) do |records|
+            #puts "RECORDS: #{records.to_a}"
+            initializer.run(records)
           end
         end
-
-        m.register_type "interval" do |*args, sql_type|
-          precision = extract_precision(sql_type)
-          OID::Interval.new(precision: precision)
-        end
-
-        # pgjdbc returns these if the column is auto-incrmenting
-        m.alias_type 'serial', 'int4'
-        m.alias_type 'bigserial', 'int8'
       end
 
-      def load_additional_types(type_map, oid = nil) # :nodoc:
-        initializer = ArjdbcTypeMapInitializer.new(type_map)
-
-        if supports_ranges?
-          query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype,
-                ns.nspname, ns.nspname = ANY(current_schemas(true)) in_ns
-              FROM pg_type as t
-              LEFT JOIN pg_range as r ON oid = rngtypid
-              JOIN pg_namespace AS ns ON t.typnamespace = ns.oid
-          SQL
+      def load_types_queries(initializer, oids)
+        query = <<~SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+            FROM pg_type as t
+            LEFT JOIN pg_range as r ON oid = rngtypid
+        SQL
+        if oids
+          if oids.all? { |e| e.kind_of? Numeric }
+            yield query + "WHERE t.oid IN (%s)" % oids.join(", ")
+          else
+            in_list = oids.map { |e| %Q{'#{e}'} }.join(", ")
+            #puts caller[0..40]
+            puts "IN_LIST = #{in_list}"
+            yield query + "WHERE t.typname IN (%s)" % in_list
+          end
         else
-          query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype,
-                ns.nspname, ns.nspname = ANY(current_schemas(true)) in_ns
-              FROM pg_type as t
-              JOIN pg_namespace AS ns ON t.typnamespace = ns.oid
-          SQL
+          yield query + initializer.query_conditions_for_known_type_names
+          yield query + initializer.query_conditions_for_known_type_types
+          yield query + initializer.query_conditions_for_array_types
         end
+      end
 
-        if oid
-          if oid.is_a? Numeric || oid.match(/^\d+$/)
-            # numeric OID
-            query += "WHERE t.oid = %s" % oid
+      def update_typemap_for_default_timezone
+        if @default_timezone != ActiveRecord.default_timezone && @timestamp_decoder
+          decoder_class = ActiveRecord.default_timezone == :utc ?
+                            PG::TextDecoder::TimestampUtc :
+                            PG::TextDecoder::TimestampWithoutTimeZone
 
-          elsif m = oid.match(/"?(\w+)"?\."?(\w+)"?/)
-            # namespace and type name
-            query += "WHERE ns.nspname = '%s' AND t.typname = '%s'" % [m[1], m[2]]
+          @timestamp_decoder = decoder_class.new(@timestamp_decoder.to_h)
+          @connection.type_map_for_results.add_coder(@timestamp_decoder)
 
-          else
-            # only type name
-            query += "WHERE t.typname = '%s' AND ns.nspname = ANY(current_schemas(true))" % oid
-          end
-        else
-          query += initializer.query_conditions_for_initial_load
-        end
+          @default_timezone = ActiveRecord.default_timezone
 
-        records = execute(query, 'SCHEMA')
-        initializer.run(records)
+          # if default timezone has changed, we need to reconfigure the connection
+          # (specifically, the session time zone)
+          configure_connection
+        end
       end
 
       def extract_scale(sql_type)

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArJdbc
-  VERSION = '70.0.0.rc1'
+  VERSION = '70.0.0.rc2'
 end

data/src/java/arjdbc/postgresql/PostgreSQLRubyJdbcConnection.java

@@ -214,6 +214,11 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         });
     }
 
+    @JRubyMethod
+    public IRubyObject exec_params(ThreadContext context, IRubyObject sql, IRubyObject binds) {
+        return execute_prepared_query(context, sql, binds, null);
+    }
+
     private transient RubyClass oidArray; // PostgreSQL::OID::Array
 
     private RubyClass oidArray(final ThreadContext context) {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-alt-adapter
 version: !ruby/object:Gem::Version
-  version: 70.0.0.rc1
+  version: 70.0.0.rc2
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek, Jesse Chavez, and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-11 00:00:00.000000000 Z
+date: 2023-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/main.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".nvimlog"