ridgepole 1.0.1 → 1.0.2.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df3bfdcffa2eb5efe360debc1e37b578cde066eca7c9893f38cd110cab576b31
-  data.tar.gz: 44af328c711fe5f4d9cf2accbf5eef8a0738daa7b7047cfb47c0ec403ee34149
+  metadata.gz: a14d5a37589fdd2639feba516071c7593f98f05f485c96401dca5f3021674330
+  data.tar.gz: 96747ebd0c5da3c8e77726e839b721aeb78c088d7d6dfd25476ac6f34421d7fb
 SHA512:
-  metadata.gz: f2d96fd5d2683583ea72cb91fcb7659c8c9f2d76b9e3b323b0eb1af99cbb737c3f7e79888aefd6b71e850ac6a34e4c7b291bcff141574bc43a28ac112efc4d2b
-  data.tar.gz: d191764d26bfb55e70a95ef9f1a806a22e97746b54dcf1616cb3e4ae58425b2d187b9d3c023f70e62c1f6a507546888871e8a5ccb410a87dd1b22601b2b71902
+  metadata.gz: 946b32832ab928d03a22caa78fe4bd6379778732817de10d9df12eb976d1feb0260cacb436ae848f47e98cae923542b4494e26690a78069dd5559a6278799286
+  data.tar.gz: 3bd4e975d7aa90162d3813f57215db79c5c0680553cb46e62cf820c4dfe6500af8c8f0845fe4799e481dfad453698439e84362d5f19ee2c0aafa454d28eae62a

data/.rubocop.yml

@@ -24,10 +24,18 @@ Layout/LineLength:
   Enabled: false
 Metrics/MethodLength:
   Enabled: false
+Metrics/ModuleLength:
+  Max: 106
 Metrics/ParameterLists:
   Enabled: false
 Metrics/PerceivedComplexity:
   Enabled: false
+Naming/MethodName:
+  Exclude:
+    - "lib/ridgepole/ext/abstract_mysql_adapter/schema_creation.rb"
+Naming/MethodParameterName:
+  Exclude:
+    - "lib/ridgepole/ext/abstract_mysql_adapter/schema_creation.rb"
 Style/Documentation:
   Enabled: false
 Style/GuardClause:

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## 1.0
 
+### 1.0.2 (Unreleased)
+
+* Add support for partitioning ([pull#374](https://github.com/ridgepole/ridgepole/pull/374))
+* Suppress warning of table option differences ([pull#378](https://github.com/ridgepole/ridgepole/pull/378))
+
 ### 1.0.1 (2022/01/15)
 
 * Fix code for RuboCop 1.24.1

data/README.md

@@ -301,6 +301,31 @@ Apply `Schemafile`
 ...
 ```
 
+## Partitioning
+
+**Notice:** PostgreSQL `PARTITION BY` must be specified with the create_table option.
+
+### List Partitioning
+
+```ruby
+create_table "articles", force: :cascade, options: "PARTITION BY LIST(id)" do |t|
+end
+
+add_partition("articles", :list, :id, partition_definitions: [{ name: 'p0', values: { in: [0,1,2] } }, { name: 'p1', values: { in: [3,4,5] } }])
+```
+
+### Range Partitioning
+
+```ruby
+create_table "articles", force: :cascade, options: "PARTITION BY RANGE(id)" do |t|
+end
+
+# postgresql
+add_partition("articles", :range, :id, partition_definitions: [{ name: 'p0', values: { from: 'MINVALUE', to: 5 }}, { name: 'p1', values: { from: 5, to: 10 } }])
+# mysql
+add_partition("articles", :range, :id, partition_definitions: [{ name: 'p0', values: { to: 5 }}, { name: 'p1', values: { to: 10 } }])
+```
+
 ## Run tests
 
 

data/lib/ridgepole/client.rb

@@ -15,7 +15,12 @@ module Ridgepole
       @parser = Ridgepole::DSLParser.new(@options)
       @diff = Ridgepole::Diff.new(@options)
 
+      if Ridgepole::ConnectionAdapters.mysql?
+        require 'ridgepole/ext/abstract_mysql_adapter/partitioning'
+        require 'ridgepole/ext/abstract_mysql_adapter/schema_creation'
+      end
       require 'ridgepole/ext/abstract_mysql_adapter/dump_auto_increment' if @options[:mysql_dump_auto_increment]
+      require 'ridgepole/ext/postgresql_adapter/partitioning' if Ridgepole::ConnectionAdapters.postgresql?
     end
 
     def dump(&block)

data/lib/ridgepole/delta.rb

@@ -310,11 +310,29 @@ execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name
       append_change_table_options(table_name, comment_literal, buf)
     end
 
+    def append_change_partition(table_name, delta, buf)
+      (delta[:add] || {}).each do |_, attrs|
+        buf.puts "create_partition #{table_name.inspect}, **#{attrs.inspect}"
+      end
+    end
+
+    def append_change_partition_definitions(table_name, partition_definitions, buf, _post_buf_for_fk)
+      (partition_definitions[:add] || []).each do |partition_name, attrs|
+        buf.puts "add_partition #{table_name.inspect}, name: #{partition_name.inspect}, values: #{attrs[:values].inspect}"
+      end
+
+      (partition_definitions[:delete] || []).each do |partition_name, _attrs|
+        buf.puts "remove_partition #{table_name.inspect}, name: #{partition_name.inspect}"
+      end
+    end
+
     def append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)
       definition = attrs[:definition] || {}
       primary_key_definition = attrs[:primary_key_definition] || {}
       indices = attrs[:indices] || {}
       foreign_keys = attrs[:foreign_keys] || {}
+      partition = attrs[:partition] || {}
+      partition_definitions = attrs[:partition_definitions] || {}
       table_options = attrs[:table_options]
       table_charset = attrs[:table_charset]
       table_collation = attrs[:table_collation]
@@ -335,6 +353,10 @@ execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name
 
       append_change_table_comment(table_name, table_comment, buf) if table_comment
 
+      append_change_partition(table_name, partition, buf) unless partition.empty?
+
+      append_change_partition_definitions(table_name, partition_definitions, buf, post_buf_for_fk) unless partition_definitions.empty?
+
       buf.puts
       pre_buf_for_fk.puts
       post_buf_for_fk.puts

data/lib/ridgepole/diff.rb

@@ -37,6 +37,9 @@ module Ridgepole
           delta[:add] ||= {}
           delta[:add][table_name] = to_attrs
         end
+        delta[:change] ||= {}
+        delta[:change][table_name] ||= {}
+        scan_partition_change(table_name, from_attrs&.fetch(:partition, nil), to_attrs&.fetch(:partition, nil), delta[:change][table_name])
       end
 
       scan_relation_info(relation_info)
@@ -182,8 +185,8 @@ module Ridgepole
       to = to.except(*PRIMARY_KEY_OPTIONS)
 
       unless from == to
-        @logger.warn(<<-MSG)
-[WARNING] Table option changes are ignored on `#{table_name}`.
+        @logger.verbose_info(<<-MSG)
+# Table option changes are ignored on `#{table_name}`.
   from: #{from}
     to: #{to}
       MSG
@@ -612,6 +615,54 @@ module Ridgepole
       end
     end
 
+    def scan_partition_change(table_name, from, to, table_delta)
+      from = (from || {}).dup
+      to = (to || {}).dup
+      partition_delta = {}
+
+      return if to.empty? && from.empty?
+
+      if from.empty? && Ridgepole::ConnectionAdapters.mysql?
+        partition_delta[:add] ||= {}
+        partition_delta[:add][table_name] = to
+      else
+        if from.present? && (to[:type] != from[:type] || to[:columns] != from[:columns])
+          @logger.warn(<<-MSG)
+"[WARNING] '#{table_name}' partition is skipped because of the different partition type.
+  to: #{to[:type]} #{to[:columns]}
+  from: #{from[:type]}" #{from[:columns]}
+MSG
+          return
+        end
+
+        raise "All partition is different. please check partition settings.to:  #{to}, from: #{from}" if from[:partition_definitions].present? && (to[:partition_definitions] & from[:partition_definitions]).empty?
+
+        scan_partition_definition_chanage(from, to, table_delta)
+      end
+
+      table_delta[:partition] = partition_delta unless partition_delta.empty?
+    end
+
+    def scan_partition_definition_chanage(from, to, table_delta)
+      partition_definitions_delta = {}
+      attrs = { type: from[:type] || to[:type] }
+
+      from_partitions = (from[:partition_definitions] || []).index_by { |partition| partition[:name] }
+      to_partitions = (to[:partition_definitions] || []).index_by { |partition| partition[:name] }
+
+      (from_partitions.keys - to_partitions.keys).each do |name|
+        partition_definitions_delta[:delete] ||= {}
+        partition_definitions_delta[:delete][name] = attrs.merge(valuve: from_partitions[name][:values])
+      end
+
+      (to_partitions.keys - from_partitions.keys).each do |name|
+        partition_definitions_delta[:add] ||= {}
+        partition_definitions_delta[:add][name] = attrs.merge(values: to_partitions[name][:values])
+      end
+
+      table_delta[:partition_definitions] = partition_definitions_delta unless partition_definitions_delta.empty?
+    end
+
     def check_table_existence(definition)
       return unless @options[:tables]
 

data/lib/ridgepole/dsl_parser/context.rb

@@ -91,6 +91,22 @@ module Ridgepole
         }
       end
 
+      def add_partition(table_name, type, columns, partition_definitions: [])
+        partition_definitions.each do |partition_definition|
+          values = partition_definition.fetch(:values)
+          raise ArgumentError unless values.is_a?(Hash)
+
+          values[:in] = Array.wrap(values[:in]) if values.key?(:in)
+          values[:to] = Array.wrap(values[:to]) if values.key?(:to)
+          values[:from] = Array.wrap(values[:from]) if values.key?(:from)
+        end
+        @__definition[table_name][:partition] = {
+          type: type,
+          columns: Array.wrap(columns),
+          partition_definitions: partition_definitions,
+        }
+      end
+
       def require(file)
         schemafile = %r{\A/}.match?(file) ? file : File.join(@__working_dir, file)
 

data/lib/ridgepole/ext/abstract_adapter/partition_definition.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PartitionDefinition
+      attr_reader :name, :values
+
+      def initialize(
+        name,
+        values
+      )
+        @name = name
+        @values = values
+      end
+    end
+  end
+end

data/lib/ridgepole/ext/abstract_adapter/partition_options.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PartitionOptions
+      attr_reader :table, :type, :columns, :partition_definitions
+
+      TYPES = %i[range list].freeze
+
+      def initialize(
+        table, type,
+        columns,
+        partition_definitions: []
+      )
+        @table = table
+        @type = type
+        @columns = Array.wrap(columns)
+        @partition_definitions = build_definitions(partition_definitions)
+      end
+
+      private
+
+      def build_definitions(definitions)
+        definitions.map do |definition|
+          next if definition.is_a?(PartitionDefinition)
+
+          PartitionDefinition.new(definition.fetch(:name), definition.fetch(:values))
+        end.compact
+      end
+    end
+  end
+end

data/lib/ridgepole/ext/abstract_adapter/partitioning.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module Ridgepole
+  module Ext
+    module AbstractAdapter
+      module Partitioning
+        def partition(*)
+          nil
+        end
+
+        def partition_tables
+          []
+        end
+
+        # SchemaStatements
+        def create_partition(*)
+          raise NotImplementedError
+        end
+
+        def add_partition(*)
+          raise NotImplementedError
+        end
+
+        def remove_partition(*)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      prepend Ridgepole::Ext::AbstractAdapter::Partitioning
+    end
+  end
+end

data/lib/ridgepole/ext/abstract_mysql_adapter/partitioning.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+
+module Ridgepole
+  module Ext
+    module AbstractMysqlAdapter
+      module Partitioning
+        def partition(table_name)
+          scope = quoted_scope(table_name)
+
+          partition_info = exec_query(<<~SQL, 'SCHEMA')
+            SELECT PARTITION_NAME, PARTITION_DESCRIPTION, PARTITION_METHOD, PARTITION_EXPRESSION
+            FROM information_schema.partitions
+            WHERE partition_name IS NOT NULL
+              AND table_schema = #{scope[:schema]}
+              AND table_name = #{scope[:name]}
+          SQL
+          return if partition_info.count == 0
+
+          type = case partition_info.first['PARTITION_METHOD']
+                 when 'LIST COLUMNS'
+                   :list
+                 when 'RANGE COLUMNS'
+                   :range
+                 else
+                   raise NotImplementedError, partition_info.first['PARTITION_METHOD'].to_s
+                 end
+          columns = partition_info.first['PARTITION_EXPRESSION'].delete('`').split(',').map(&:to_sym)
+
+          partition_definitions = partition_info.map do |row|
+            values = case type
+                     when :list
+                       { in: instance_eval("[#{row['PARTITION_DESCRIPTION'].gsub(/\(/, '[').gsub(/\)/, ']')}] # [1,2]", __FILE__, __LINE__) }
+                     when :range
+                       { to: instance_eval("[#{row['PARTITION_DESCRIPTION']}] # [1,2]", __FILE__, __LINE__) }
+                     else
+                       raise NotImplementedError
+                     end
+
+            { name: row['PARTITION_NAME'], values: values }
+          end
+
+          ActiveRecord::ConnectionAdapters::PartitionOptions.new(table_name, type, columns, partition_definitions: partition_definitions)
+        end
+
+        # SchemaStatements
+        def create_partition(table_name, type:, columns:, partition_definitions:)
+          execute schema_creation.accept(ActiveRecord::ConnectionAdapters::PartitionOptions.new(table_name, type, columns, partition_definitions: partition_definitions))
+        end
+
+        def add_partition(table_name, name:, values:)
+          pd = ActiveRecord::ConnectionAdapters::PartitionDefinition.new(name, values)
+          execute "ALTER TABLE #{quote_table_name(table_name)} ADD PARTITION (#{schema_creation.accept(pd)})"
+        end
+
+        def remove_partition(table_name, name:)
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP PARTITION #{name}"
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractMysqlAdapter < AbstractAdapter
+      prepend Ridgepole::Ext::AbstractMysqlAdapter::Partitioning
+    end
+  end
+end

data/lib/ridgepole/ext/abstract_mysql_adapter/schema_creation.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/mysql/schema_creation'
+
+module Ridgepole
+  module Ext
+    module AbstractMysqlAdapter
+      module SchemaCreation
+        def visit_PartitionOptions(o)
+          sqls = o.partition_definitions.map { |partition_definition| accept partition_definition }
+          function = case o.type
+                     when :list
+                       "LIST COLUMNS(#{o.columns.map { |column| quote_column_name(column) }.join(',')})"
+                     when :range
+                       "RANGE COLUMNS(#{o.columns.map { |column| quote_column_name(column) }.join(',')})"
+                     else
+                       raise NotImplementedError
+                     end
+          "ALTER TABLE #{quote_table_name(o.table)} PARTITION BY #{function} (#{sqls.join(',')})"
+        end
+
+        def visit_PartitionDefinition(o)
+          if o.values.key?(:in)
+            "PARTITION #{o.name} VALUES IN (#{o.values[:in].map do |value|
+              value.is_a?(Array) ? "(#{value.map(&:inspect).join(',')})" : value.inspect
+            end.join(',')})"
+          elsif o.values.key?(:to)
+            "PARTITION #{o.name} VALUES LESS THAN (#{o.values[:to].map(&:inspect).join(',')})"
+          else
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class SchemaCreation
+        prepend Ridgepole::Ext::AbstractMysqlAdapter::SchemaCreation
+      end
+    end
+  end
+end

data/lib/ridgepole/ext/postgresql_adapter/partitioning.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module Ridgepole
+  module Ext
+    module PostgreSQLAdapter
+      module Partitioning
+        def supports_partitions?
+          ActiveRecord::VERSION::MAJOR >= 6 && postgresql_version >= 100_000 # >= 10.0
+        end
+
+        def table_options(table_name)
+          options = partition_options(table_name)
+          if options
+            (super || {}).merge(options: "PARTITION BY #{options[:type].to_s.upcase}(#{options[:columns].join(',')})")
+          else
+            super
+          end
+        end
+
+        def partition_options(table_name)
+          return unless supports_partitions?
+
+          scope = quoted_scope(table_name)
+          result = query_value(<<~SQL, 'SCHEMA')
+            SELECT pg_get_partkeydef(t.oid)
+            FROM pg_class t
+              LEFT JOIN pg_namespace n ON n.oid = t.relnamespace
+            WHERE t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
+          SQL
+          return unless result
+
+          type, *columns = result.scan(/\w+/).map { |value| value.downcase.to_sym }
+          { type: type, columns: columns }
+        end
+
+        def partition(table_name)
+          options = partition_options(table_name)
+          return unless options
+
+          scope = quoted_scope(table_name)
+          partition_info = query(<<~SQL, 'SCHEMA')
+            SELECT p.relname, pg_get_expr(p.relpartbound, p.oid, true)
+            FROM pg_class t
+            JOIN pg_inherits i on i.inhparent = t.oid
+            JOIN pg_class p on p.oid = i.inhrelid
+            WHERE t.relname = #{scope[:name]}
+              AND p.relnamespace::regnamespace::text = #{scope[:schema]}
+            ORDER BY p.relname
+          SQL
+
+          partition_definitions = partition_info.map do |row|
+            values = case options[:type]
+                     when :list
+                       values = row[1].match(/FOR VALUES IN \((?<csv>.+)\)$/)[:csv].split(',').map(&:strip).map { |value| cast_value(value) }
+                       { in: Array.wrap(values) }
+                     when :range
+                       match = row[1].match(/FOR VALUES FROM \((?<from>.+)\) TO \((?<to>.+)\)/)
+                       from = match[:from].split(',').map(&:strip).map { |value| cast_value(value) }
+                       to = match[:to].split(',').map(&:strip).map { |value| cast_value(value) }
+                       { from: from, to: to }
+                     else
+                       raise NotImplementedError
+                     end
+            { name: row[0], values: values }
+          end
+
+          ActiveRecord::ConnectionAdapters::PartitionOptions.new(table_name, options[:type], options[:columns], partition_definitions: partition_definitions)
+        end
+
+        def cast_value(value)
+          Integer(value)
+        rescue ArgumentError
+          value.delete(%q("')) # "
+        end
+
+        def quote_value(value)
+          if %w[MINVALUE MAXVALUE].include?(value)
+            value
+          else
+            quote(value)
+          end
+        end
+
+        def partition_tables
+          partition_info = query(<<~SQL, 'SCHEMA')
+            SELECT p.relname
+            FROM pg_class t
+            JOIN pg_inherits i on i.inhparent = t.oid
+            JOIN pg_class p on p.oid = i.inhrelid
+            ORDER BY p.relname
+          SQL
+          partition_info.map { |row| row[0] }
+        end
+
+        # SchemaStatements
+        def add_partition(table_name, name:, values:)
+          condition = if values.key?(:in)
+                        "FOR VALUES IN (#{values[:in].map { |v| quote_value(v) }.join(',')})"
+                      elsif values.key?(:to)
+                        from = values[:from].map { |v| quote_value(v) }.join(',')
+                        to = values[:to].map { |v| quote_value(v) }.join(',')
+                        "FOR VALUES FROM (#{from}) TO (#{to})"
+                      else
+                        raise NotImplementedError
+                      end
+          create_table(name, id: false, options: "PARTITION OF #{table_name} #{condition}")
+        end
+
+        def remove_partition(_table_name, name:)
+          drop_table(name)
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      prepend Ridgepole::Ext::PostgreSQLAdapter::Partitioning
+    end
+  end
+end

data/lib/ridgepole/ext/schema_dumper.rb

@@ -45,6 +45,30 @@ module Ridgepole
           stream.puts add_foreign_key_statements.sort.join("\n")
         end
       end
+
+      def tables(stream)
+        original = ignore_tables.dup
+        ignore_tables.concat(@connection.partition_tables)
+        super
+      ensure
+        self.ignore_tables = original
+      end
+
+      def table(table, stream)
+        super
+        partition(table, stream)
+      end
+
+      def partition(table, stream)
+        if (partition = @connection.partition(table))
+          partition_definitions = partition.partition_definitions.map do |partition_definition|
+            "{ name: #{partition_definition.name.inspect}, values: #{partition_definition.values} }"
+          end.join(' ,')
+
+          stream.puts "  add_partition #{partition.table.inspect}, #{partition.type.inspect}, #{partition.columns.inspect}, partition_definitions: [#{partition_definitions}]"
+          stream.puts
+        end
+      end
     end
   end
 end

data/lib/ridgepole/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ridgepole
-  VERSION = '1.0.1'
+  VERSION = '1.0.2.beta'
 end

data/lib/ridgepole.rb

@@ -16,6 +16,9 @@ require 'diffy'
 module Ridgepole; end
 
 require 'ridgepole/ext/abstract_adapter/disable_table_options'
+require 'ridgepole/ext/abstract_adapter/partition_definition'
+require 'ridgepole/ext/abstract_adapter/partition_options'
+require 'ridgepole/ext/abstract_adapter/partitioning'
 require 'ridgepole/ext/pp_sort_hash'
 require 'ridgepole/ext/schema_dumper'
 require 'ridgepole/client'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ridgepole
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2.beta
 platform: ruby
 authors:
 - Genki Sugawara
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-15 00:00:00.000000000 Z
+date: 2022-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -306,7 +306,13 @@ files:
 - lib/ridgepole/dumper.rb
 - lib/ridgepole/execute_expander.rb
 - lib/ridgepole/ext/abstract_adapter/disable_table_options.rb
+- lib/ridgepole/ext/abstract_adapter/partition_definition.rb
+- lib/ridgepole/ext/abstract_adapter/partition_options.rb
+- lib/ridgepole/ext/abstract_adapter/partitioning.rb
 - lib/ridgepole/ext/abstract_mysql_adapter/dump_auto_increment.rb
+- lib/ridgepole/ext/abstract_mysql_adapter/partitioning.rb
+- lib/ridgepole/ext/abstract_mysql_adapter/schema_creation.rb
+- lib/ridgepole/ext/postgresql_adapter/partitioning.rb
 - lib/ridgepole/ext/pp_sort_hash.rb
 - lib/ridgepole/ext/schema_dumper.rb
 - lib/ridgepole/external_sql_executer.rb
@@ -332,9 +338,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.2.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.32
 signing_key: