padrino-support 0.16.0.pre4 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ba7cc454018e6e5420beac5070d92fbc74cba209fb0e275505bdacdfd481bee
-  data.tar.gz: f6d0af71b97a90ee991d27a4597acdfabe23c17b094257724ae23e14b8fc6bf3
+  metadata.gz: 59a80f867b03be39e12377b2ce6d3559c20b3108b926f3dbb05592a7bffb23af
+  data.tar.gz: 74d3a220b6a2b402089a5207cae2e8b4c53a2f326941ba6b3845b1da20e0a25c
 SHA512:
-  metadata.gz: ada14d2a7c15d9444f8dca867ca17e241600cf9735e67fbaf8419b7c8083715d5ee5801e97d906e877f3ef513f687ca4b78c1c4177e75a244d9c89cdd7747d7b
-  data.tar.gz: 618f62e709476c1dcd30d76e7684255dd75b17c9bf79ff95661286ab377fdc9b2ce2f60cf65eb161e33ef4cd1cc9a1d83e3a5998c14fcc716db2b41d725dc217
+  metadata.gz: a2d7bfe9f8f11786e6b81c5a436c213e9b54c02be401975f284d9f900ea6d1fae753d7c50bc878fca58e929f78254191840457c7c05b4374964f55a0820ffa04
+  data.tar.gz: 38ce9e649ee47193caef5c697e9c187f4b1f5309c930f8cf29c093ed0282c4759d536bcba14b859267e102a6bf94f7bf53565392db53136dea0149d096297c27

data/Rakefile

@@ -1 +1 @@
-require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')
+require_relative '../gem_rake_helper'

data/lib/padrino-support/core_ext/string/colorize.rb

@@ -17,23 +17,23 @@ class String
     # Returns colors integer mapping
     def self.colors
       @_colors ||= {
-        :default => 9,
-        :black   => 30,
-        :red     => 31,
-        :green   => 32,
-        :yellow  => 33,
-        :blue    => 34,
-        :magenta => 35,
-        :cyan    => 36,
-        :white   => 37
+        default: 9,
+        black: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        magenta: 35,
+        cyan: 36,
+        white: 37
       }
     end
 
     # Returns modes integer mapping
     def self.modes
       @_modes ||= {
-        :default => 0,
-        :bold    => 1
+        default: 0,
+        bold: 1
       }
     end
 
@@ -44,7 +44,7 @@ class String
         define_method(color) do |target, mode_name = :default|
           mode = modes[mode_name] || modes[:default]
           "\e[#{mode};#{value}m" << target << "\e[0m"
-         end
+        end
       end
     end
   end

data/lib/padrino-support/default_inflections.rb

@@ -1,10 +1,11 @@
 # frozen-string-literal: true
+
 ##
 # This module is based on Sequel 5.4.0
 # sequel-5.4.0/lib/sequel/model/default_inflections.rb
 #
 module Padrino
-  # Proc that is instance evaled to create the default inflections for both the
+  # Proc that is instance executed to create the default inflections for both the
   # model inflector and the inflector extension.
   DEFAULT_INFLECTIONS_PROC = proc do
     plural(/$/, 's')
@@ -45,6 +46,6 @@ module Padrino
     irregular('quiz', 'quizzes')
     irregular('testis', 'testes')
 
-    uncountable(%w(equipment information rice money species series fish sheep news))
+    uncountable(%w[equipment information rice money species series fish sheep news])
   end
 end

data/lib/padrino-support/file_set.rb

@@ -2,16 +2,17 @@
 # FileSet helper method for iterating and interacting with files inside a directory
 #
 module FileSet
-  extend self
+  module_function
+
   ##
   # Iterates over every file in the glob pattern and yields to a block
   # Returns the list of files matching the glob pattern
   # FileSet.glob('padrino-core/application/*.rb', __FILE__) { |file| load file }
   #
-  def glob(glob_pattern, file_path=nil)
+  def glob(glob_pattern, file_path = nil, &block)
     glob_pattern = File.join(File.dirname(file_path), glob_pattern) if file_path
     file_list = Dir.glob(glob_pattern).sort
-    file_list.each{ |file| yield(file) }
+    file_list.each(&block)
     file_list
   end
 
@@ -19,7 +20,7 @@ module FileSet
   # Requires each file matched in the glob pattern into the application
   # FileSet.glob_require('padrino-core/application/*.rb', __FILE__)
   #
-  def glob_require(glob_pattern, file_path=nil)
+  def glob_require(glob_pattern, file_path = nil)
     glob(glob_pattern, file_path) { |f| require f }
   end
 end

data/lib/padrino-support/inflections.rb

@@ -22,18 +22,18 @@ module Padrino
   # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
   # already have been loaded.
   module Inflections
-    CAMELIZE_CONVERT_REGEXP = /(^|_)(.)/.freeze
-    CAMELIZE_MODULE_REGEXP = /\/(.?)/.freeze
+    CAMELIZE_CONVERT_REGEXP = /(^|_)(.)/
+    CAMELIZE_MODULE_REGEXP = %r{/(.?)}
     DASH = '-'.freeze
-    DEMODULIZE_CONVERT_REGEXP = /^.*::/.freeze
-    EMPTY_STRING= ''.freeze
+    DEMODULIZE_CONVERT_REGEXP = /^.*::/
+    EMPTY_STRING = ''.freeze
     SLASH = '/'.freeze
-    VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+    VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/
     UNDERSCORE = '_'.freeze
-    UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)([A-Z][a-z])/.freeze
-    UNDERSCORE_CONVERT_REGEXP2 = /([a-z\d])([A-Z])/.freeze
+    UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)([A-Z][a-z])/
+    UNDERSCORE_CONVERT_REGEXP2 = /([a-z\d])([A-Z])/
     UNDERSCORE_CONVERT_REPLACE = '\1_\2'.freeze
-    UNDERSCORE_MODULE_REGEXP = /::/.freeze
+    UNDERSCORE_MODULE_REGEXP = /::/
 
     @plurals, @singulars, @uncountables = [], [], []
 
@@ -70,8 +70,8 @@ module Padrino
     #   irregular 'octopus', 'octopi'
     #   irregular 'person', 'people'
     def self.irregular(singular, plural)
-      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
-      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+      plural(Regexp.new("(#{singular[0, 1]})#{singular[1..]}$", 'i'), "\\1#{plural[1..]}")
+      singular(Regexp.new("(#{plural[0, 1]})#{plural[1..]}$", 'i'), "\\1#{singular[1..]}")
     end
 
     # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
@@ -87,7 +87,7 @@ module Padrino
     # The replacement should always be a string that may include references to the matched data from the rule.
     #
     # Example:
-    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y')
     def self.singular(rule, replacement)
       @singulars.insert(0, [rule, replacement])
     end
@@ -104,76 +104,79 @@ module Padrino
 
     instance_eval(&DEFAULT_INFLECTIONS_PROC)
 
-    extend self
+    module_function
 
     # Convert the given string to CamelCase.  Will also convert '/' to '::' which is useful for converting paths to namespaces.
-    def camelize(s)
-      s = s.to_s
-      return s.camelize if s.respond_to?(:camelize)
-      s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase}
-      s
+    def camelize(str)
+      str = str.to_s
+      return str.camelize if str.respond_to?(:camelize)
+      str.gsub(CAMELIZE_MODULE_REGEXP) { |x| "::#{x[-1..].upcase unless x == SLASH}" }.gsub(CAMELIZE_CONVERT_REGEXP) { |x| x[-1..].upcase }
     end
 
     # Tries to find a declared constant with the name specified
     # in the string. It raises a NameError when the name is not in CamelCase
     # or is not initialized.
-    def constantize(s)
-      s = s.to_s
-      return s.constantize if s.respond_to?(:constantize)
-      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s)
+    def constantize(str)
+      str = str.to_s
+      return str.constantize if str.respond_to?(:constantize)
+      raise(NameError, "#{str.inspect} is not a valid constant name!") unless (m = VALID_CONSTANT_NAME_REGEXP.match(str))
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
 
     # Removes the module part from the expression in the string
-    def demodulize(s)
-      s = s.to_s
-      return s.demodulize if s.respond_to?(:demodulize)
-      s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
+    def demodulize(str)
+      str = str.to_s
+      return str.demodulize if str.respond_to?(:demodulize)
+      str.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
     end
 
     # Returns the plural form of the word in the string.
-    def pluralize(s)
-      s = s.to_s
-      return s.pluralize if s.respond_to?(:pluralize)
-      result = s.dup
-      Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
+    def pluralize(str)
+      str = str.to_s
+      return str.pluralize if str.respond_to?(:pluralize)
+      result = str.dup
+      Inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } unless Inflections.uncountables.include?(str.downcase)
       result
     end
 
     # The reverse of pluralize, returns the singular form of a word in a string.
-    def singularize(s)
-      s = s.to_s
-      return s.singularize if s.respond_to?(:singularize)
-      result = s.dup
-      Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
+    def singularize(str)
+      str = str.to_s
+      return str.singularize if str.respond_to?(:singularize)
+      result = str.dup
+      Inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } unless Inflections.uncountables.include?(str.downcase)
       result
     end
 
     # The reverse of camelize. Makes an underscored form from the expression in the string.
     # Also changes '::' to '/' to convert namespaces to paths.
-    def underscore(s)
-      s = s.to_s
-      return s.underscore if s.respond_to?(:underscore)
-      s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE).
-        gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase
+    def underscore(str)
+      str = str.to_s
+      return str.underscore if str.respond_to?(:underscore)
+
+      str.gsub(UNDERSCORE_MODULE_REGEXP, SLASH)
+         .gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE)
+         .gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE)
+         .tr(DASH, UNDERSCORE)
+         .downcase
     end
 
     ##
     # Capitalizes the first word, turns underscores into spaces, and strips a trailing '_id' if present.
     #
-    def humanize(s)
-      s = s.to_s
-      return s.humanize if s.respond_to?(:humanize)
-      s.gsub(/_id$/, '').tr('_', ' ').capitalize
+    def humanize(str)
+      str = str.to_s
+      return str.humanize if str.respond_to?(:humanize)
+      str.gsub(/_id$/, '').tr('_', ' ').capitalize
     end
 
     ##
     # Create a class name from a plural table name like Rails does for table names to models.
     #
-    def classify(s)
-      s = s.to_s
-      return s.classify if s.respond_to?(:classify)
-      camelize(singularize(s.sub(/.*\./, '')))
+    def classify(str)
+      str = str.to_s
+      return str.classify if str.respond_to?(:classify)
+      camelize(singularize(str.sub(/.*\./, '')))
     end
   end
 end

data/lib/padrino-support/utils.rb

@@ -2,32 +2,32 @@ require 'cgi'
 
 module Padrino
   module Utils
-    extend self
+    module_function
 
     ##
     # Builds an URI query from a Hash or any Object.
     #
     # Examples (~ marks here that output is actually escaped by CGI):
     #
-    #   Utils.build_uri_query(:a => 1, :b => 2)           #=> "a=1&b=2"
-    #   Utils.build_uri_query(:a => [1, 2])               #=> ~"a[]=1&a[]=2"
-    #   Utils.build_uri_query([1, 2], 'namespace')        #=> ~"namespace[]=1&namespace[]=2"
-    #   Utils.build_uri_query(:a => { :d => 2 }, :b => 3) #=> ~"a[d]=2&b=3"
+    #   Utils.build_uri_query(a: 1, b: 2)           # => 'a=1&b=2'
+    #   Utils.build_uri_query(a: [1, 2])            # => ~'a[]=1&a[]=2'
+    #   Utils.build_uri_query([1, 2], 'namespace')  # => ~'namespace[]=1&namespace[]=2'
+    #   Utils.build_uri_query(a: { d: 2 }, b: 3)    # => ~'a[d]=2&b=3'
     #
     def build_uri_query(object, namespace = nil)
       case object
       when Hash
         object.map do |key, value|
-          next if value == {} || value == []
+          next if [{}, []].include?(value)
           build_uri_query(value, namespace ? "#{namespace}[#{key}]" : key)
         end.compact.join('&')
       when Array
-        fail ArgumentError, 'namespace is missing' unless namespace
+        raise ArgumentError, 'namespace is missing' unless namespace
         (object.empty? ? [''] : object).map do |value|
           build_uri_query(value, "#{namespace}[]")
         end.join('&')
       else
-        fail ArgumentError, 'namespace is missing' unless namespace
+        raise ArgumentError, 'namespace is missing' unless namespace
         "#{CGI.escape(namespace.to_s)}=#{CGI.escape(object.to_s)}"
       end
     end
@@ -38,7 +38,7 @@ module Padrino
     def deep_dup(object)
       case object
       when Array
-        object.map{ |value| deep_dup(value) }
+        object.map { |value| deep_dup(value) }
       when Hash
         object.each_with_object(object.dup.clear) do |(key, value), new_hash|
           new_hash[deep_dup(key)] = deep_dup(value)

data/lib/padrino-support.rb

@@ -5,7 +5,7 @@ require 'padrino-support/core_ext/string/colorize'
 require 'padrino-support/file_set'
 require 'padrino-support/utils'
 
-if ENV["AS_VERSION"]
+if ENV['AS_VERSION']
   # require ActiveSupport features for tests or legacy projects
   require 'active_support/core_ext/string/output_safety'      # SafeBuffer and html_safe
   require 'active_support/core_ext/object/blank'              # present?
@@ -27,7 +27,7 @@ end
 #
 if defined?(I18n) && !defined?(PADRINO_I18N_LOCALE)
   PADRINO_I18N_LOCALE = true
-  I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-support/locale/*.yml"]
+  I18n.load_path += Dir["#{__dir__}/padrino-support/locale/*.yml"]
 end
 
 ##
@@ -35,5 +35,5 @@ end
 # In reloader for accessing class_name Foo._orig_klass_name
 #
 class Module
-  alias :_orig_klass_name :name
+  alias _orig_klass_name name
 end

data/padrino-support.gemspec

@@ -1,25 +1,25 @@
 #!/usr/bin/env gem build
 # encoding: utf-8
 
-require File.expand_path("../../padrino-core/lib/padrino-core/version.rb", __FILE__)
+require File.expand_path('../padrino-core/lib/padrino-core/version.rb', __dir__)
 
 Gem::Specification.new do |s|
-  s.name = "padrino-support"
-  s.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu", "Igor Bochkariov"]
-  s.email = "padrinorb@gmail.com"
-  s.summary = "Support for padrino"
-  s.homepage = "http://www.padrinorb.com"
-  s.description = "A number of support methods and extensions for Padrino framework"
-  s.required_ruby_version = ">= 2.7.8"
-  s.required_rubygems_version = ">= 1.3.6"
+  s.name = 'padrino-support'
+  s.authors = ['Padrino Team', 'Nathan Esquenazi', "Davide D'Agostino", 'Arthur Chiu', 'Igor Bochkariov']
+  s.email = 'padrinorb@gmail.com'
+  s.summary = 'Support for padrino'
+  s.homepage = 'http://www.padrinorb.com'
+  s.description = 'A number of support methods and extensions for Padrino framework'
+  s.required_ruby_version = '>= 2.7.8'
+  s.required_rubygems_version = '>= 1.3.6'
   s.version = Padrino.version
-  s.date = Time.now.strftime("%Y-%m-%d")
-  s.license = "MIT"
+  s.date = Time.now.strftime('%Y-%m-%d')
+  s.license = 'MIT'
 
-  s.extra_rdoc_files = Dir["*.rdoc"]
+  s.extra_rdoc_files = Dir['*.rdoc']
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  s.rdoc_options  = ["--charset=UTF-8"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+  s.rdoc_options  = ['--charset=UTF-8']
 end

data/test/helper.rb

@@ -1,5 +1,5 @@
 ENV['RACK_ENV'] = 'test'
-PADRINO_ROOT = File.dirname(__FILE__) unless defined?(PADRINO_ROOT)
+PADRINO_ROOT = __dir__ unless defined?(PADRINO_ROOT)
 
 require 'minitest/autorun'
 require 'minitest/pride'

data/test/test_colorize.rb

@@ -1,31 +1,31 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require_relative 'helper'
 
-describe "String#colorize" do
-  it "should colorize text correctly" do
-    assert_equal "\e[0;34mHello world\e[0m", "Hello world".colorize(:blue)
-    assert_equal "\e[0;30mHello world\e[0m", "Hello world".colorize(:black)
-    assert_equal "\e[0;31mHello world\e[0m", "Hello world".colorize(:red)
-    assert_equal "\e[0;32mHello world\e[0m", "Hello world".colorize(:green)
-    assert_equal "\e[0;33mHello world\e[0m", "Hello world".colorize(:yellow)
-    assert_equal "\e[0;34mHello world\e[0m", "Hello world".colorize(:blue)
-    assert_equal "\e[0;35mHello world\e[0m", "Hello world".colorize(:magenta)
-    assert_equal "\e[0;36mHello world\e[0m", "Hello world".colorize(:cyan)
-    assert_equal "\e[0;37mHello world\e[0m", "Hello world".colorize(:white)
+describe 'String#colorize' do
+  it 'should colorize text correctly' do
+    assert_equal "\e[0;34mHello world\e[0m", 'Hello world'.colorize(:blue)
+    assert_equal "\e[0;30mHello world\e[0m", 'Hello world'.colorize(:black)
+    assert_equal "\e[0;31mHello world\e[0m", 'Hello world'.colorize(:red)
+    assert_equal "\e[0;32mHello world\e[0m", 'Hello world'.colorize(:green)
+    assert_equal "\e[0;33mHello world\e[0m", 'Hello world'.colorize(:yellow)
+    assert_equal "\e[0;34mHello world\e[0m", 'Hello world'.colorize(:blue)
+    assert_equal "\e[0;35mHello world\e[0m", 'Hello world'.colorize(:magenta)
+    assert_equal "\e[0;36mHello world\e[0m", 'Hello world'.colorize(:cyan)
+    assert_equal "\e[0;37mHello world\e[0m", 'Hello world'.colorize(:white)
   end
 
-  it "should colorize text when using color name method" do
-    assert_equal "\e[0;30mHello world\e[0m", String::Colorizer.black("Hello world")
-    assert_equal "\e[0;31mHello world\e[0m", String::Colorizer.red("Hello world")
-    assert_equal "\e[0;32mHello world\e[0m", String::Colorizer.green("Hello world")
-    assert_equal "\e[0;33mHello world\e[0m", String::Colorizer.yellow("Hello world")
-    assert_equal "\e[0;34mHello world\e[0m", String::Colorizer.blue("Hello world")
-    assert_equal "\e[0;35mHello world\e[0m", String::Colorizer.magenta("Hello world")
-    assert_equal "\e[0;36mHello world\e[0m", String::Colorizer.cyan("Hello world")
-    assert_equal "\e[0;37mHello world\e[0m", String::Colorizer.white("Hello world")
+  it 'should colorize text when using color name method' do
+    assert_equal "\e[0;30mHello world\e[0m", String::Colorizer.black('Hello world')
+    assert_equal "\e[0;31mHello world\e[0m", String::Colorizer.red('Hello world')
+    assert_equal "\e[0;32mHello world\e[0m", String::Colorizer.green('Hello world')
+    assert_equal "\e[0;33mHello world\e[0m", String::Colorizer.yellow('Hello world')
+    assert_equal "\e[0;34mHello world\e[0m", String::Colorizer.blue('Hello world')
+    assert_equal "\e[0;35mHello world\e[0m", String::Colorizer.magenta('Hello world')
+    assert_equal "\e[0;36mHello world\e[0m", String::Colorizer.cyan('Hello world')
+    assert_equal "\e[0;37mHello world\e[0m", String::Colorizer.white('Hello world')
   end
 
-  it "should be possible to set the mode" do
-    assert_equal "\e[1;34mHello world\e[0m", "Hello world".colorize(:color => :blue, :mode => :bold)
-    assert_equal "\e[1;34mHello world\e[0m", String::Colorizer.blue("Hello world", :bold)
+  it 'should be possible to set the mode' do
+    assert_equal "\e[1;34mHello world\e[0m", 'Hello world'.colorize(color: :blue, mode: :bold)
+    assert_equal "\e[1;34mHello world\e[0m", String::Colorizer.blue('Hello world', :bold)
   end
 end

data/test/test_utils.rb

@@ -1,14 +1,14 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require_relative 'helper'
 
 class Minitest::Spec
-  def assert_query_equal(expected, actual, namespace=nil)
+  def assert_query_equal(expected, actual, namespace = nil)
     assert_equal expected.split('&').sort, Padrino::Utils.build_uri_query(actual, namespace).split('&').sort
   end
 end
 
 describe 'Padrino::Utils.build_uri_query' do
   it 'should do simple conversion' do
-    assert_query_equal 'a=10', :a => 10
+    assert_query_equal 'a=10', a: 10
   end
 
   it 'should do cgi escaping' do
@@ -16,45 +16,39 @@ describe 'Padrino::Utils.build_uri_query' do
   end
 
   it 'should expand nested hashes' do
-    assert_query_equal 'person%5Blogin%5D=seckar&person%5Bname%5D=Nicholas',
-      :person => { :login => 'seckar', :name => 'Nicholas' }
+    assert_query_equal 'person%5Blogin%5D=seckar&person%5Bname%5D=Nicholas', person: {
+      login: 'seckar', name: 'Nicholas'
+    }
   end
 
   it 'should expand deeply nested hashes' do
-    assert_query_equal 'account%5Bperson%5D%5Bid%5D=20&person%5Bid%5D=10',
-      { :account => { :person => { :id => 20 } }, :person => {:id => 10} }
+    assert_query_equal 'account%5Bperson%5D%5Bid%5D=20&person%5Bid%5D=10', {
+      account: { person: { id: 20 } },
+      person: { id: 10 }
+    }
   end
 
   it 'should accept arrays' do
-    assert_query_equal 'person%5Bid%5D%5B%5D=10&person%5Bid%5D%5B%5D=20',
-      :person => {:id => [10, 20]}
+    assert_query_equal 'person%5Bid%5D%5B%5D=10&person%5Bid%5D%5B%5D=20', person: { id: [10, 20] }
   end
 
   it 'should accept empty arrays' do
-    assert_query_equal "person%5B%5D=",
-      [],
-      'person'
+    assert_query_equal 'person%5B%5D=', [], 'person'
   end
 
   it 'should expand nested hashes' do
-    assert_query_equal '',
-      {}
-    assert_query_equal 'a=1&b%5Bc%5D=3',
-      { a: 1, b: { c: 3, d: {} } }
-    assert_query_equal '',
-      { a: {b: {c: {}}} }
-    assert_query_equal 'b%5Bc%5D=false&b%5Be%5D=&b%5Bf%5D=&p=12',
-      { p: 12, b: { c: false, e: nil, f: '' } }
-    assert_query_equal 'b%5Bc%5D=3&b%5Bf%5D=',
-      { b: { c: 3, k: {}, f: '' } }
-    assert_query_equal 'b=3',
-      {a: [], b: 3}
+    assert_query_equal '', {}
+    assert_query_equal 'a=1&b%5Bc%5D=3', { a: 1, b: { c: 3, d: {} } }
+    assert_query_equal '', { a: { b: { c: {} } } }
+    assert_query_equal 'b%5Bc%5D=false&b%5Be%5D=&b%5Bf%5D=&p=12', { p: 12, b: { c: false, e: nil, f: '' } }
+    assert_query_equal 'b%5Bc%5D=3&b%5Bf%5D=', { b: { c: 3, k: {}, f: '' } }
+    assert_query_equal 'b=3', { a: [], b: 3 }
   end
 
   it 'should accept namespace for hashes' do
-    assert_query_equal "user%5Bname%5D=Nakshay&user%5Bnationality%5D=Indian", 
-      { name: 'Nakshay', nationality: 'Indian' },
-      'user'
+    assert_query_equal 'user%5Bname%5D=Nakshay&user%5Bnationality%5D=Indian', {
+      name: 'Nakshay', nationality: 'Indian'
+    }, 'user'
   end
 end
 
@@ -68,7 +62,7 @@ describe 'Padrino::Utils.deep_dup' do
   end
 
   it 'should recursively dup hash' do
-    hash = { :a => { :b => 'b' } }
+    hash = { a: { b: 'b' } }
     dup = Padrino::Utils.deep_dup(hash)
     dup[:a][:c] = 'c'
     refute_includes hash[:a], :c
@@ -76,7 +70,7 @@ describe 'Padrino::Utils.deep_dup' do
   end
 
   it 'should recursively dup array with hash' do
-    array = [1, { :a => 2, :b => 3 } ]
+    array = [1, { a: 2, b: 3 }]
     dup = Padrino::Utils.deep_dup(array)
     dup[1][:c] = 4
     refute_includes array[1], :c
@@ -84,7 +78,7 @@ describe 'Padrino::Utils.deep_dup' do
   end
 
   it 'should recursively dup hash with array' do
-    hash = { :a => [1, 2] }
+    hash = { a: [1, 2] }
     dup = Padrino::Utils.deep_dup(hash)
     dup[:a][2] = 'c'
     assert_equal 2, hash[:a].size
@@ -93,7 +87,7 @@ describe 'Padrino::Utils.deep_dup' do
 
   it 'should dup initial hash values' do
     zero_hash = Hash.new 0
-    hash = { :a => zero_hash }
+    hash = { a: zero_hash }
     dup = Padrino::Utils.deep_dup(hash)
     assert_equal 0, dup[:a][44]
   end
@@ -102,7 +96,7 @@ describe 'Padrino::Utils.deep_dup' do
     object = Object.new
     dup = Padrino::Utils.deep_dup(object)
     dup.instance_variable_set(:@a, 1)
-    assert !object.instance_variable_defined?(:@a)
+    refute object.instance_variable_defined?(:@a)
     assert dup.instance_variable_defined?(:@a)
   end
 
@@ -115,7 +109,7 @@ end
 
 describe 'Padrino::Utils.symbolize_keys' do
   it 'should symbolize string keys' do
-    assert_equal({ :a  => 1, :b  => 2 }, Padrino::Utils.symbolize_keys('a' => 1, 'b' => 2))
+    assert_equal({ a: 1, b: 2 }, Padrino::Utils.symbolize_keys('a' => 1, 'b' => 2))
   end
 
   it 'should not fail on non-symbolizable keys' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: padrino-support
 version: !ruby/object:Gem::Version
-  version: 0.16.0.pre4
+  version: 0.16.0
 platform: ruby
 authors:
 - Padrino Team
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-19 00:00:00.000000000 Z
+date: 2025-12-02 00:00:00.000000000 Z
 dependencies: []
 description: A number of support methods and extensions for Padrino framework
 email: padrinorb@gmail.com
@@ -72,9 +72,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: 1.3.6
 requirements: []
 rubygems_version: 3.4.19
 signing_key: