acts-as-taggable-on 8.1.0 → 9.0.0

data/lib/acts_as_taggable_on/taggable/tagged_with_query/any_tags_query.rb

@@ -1,70 +1,74 @@
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  class AnyTagsQuery < QueryBase
-    def build
-      taggable_model.select(all_fields)
-                    .where(model_has_at_least_one_tag)
-                    .order(Arel.sql(order_conditions))
-                    .readonly(false)
-    end
+# frozen_string_literal: true
 
-    private
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class AnyTagsQuery < QueryBase
+        def build
+          taggable_model.select(all_fields)
+                        .where(model_has_at_least_one_tag)
+                        .order(Arel.sql(order_conditions))
+                        .readonly(false)
+        end
 
-    def all_fields
-      taggable_arel_table[Arel.star]
-    end
+        private
 
-    def model_has_at_least_one_tag
-      tagging_arel_table.project(Arel.star).where(at_least_one_tag).exists
-    end
+        def all_fields
+          taggable_arel_table[Arel.star]
+        end
 
-    def at_least_one_tag
-      exists_contition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
-                          .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-                          .and(
-                            tagging_arel_table[:tag_id].in(
-                              tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
-                            )
-                          )
+        def model_has_at_least_one_tag
+          tagging_arel_table.project(Arel.star).where(at_least_one_tag).exists
+        end
 
-      if options[:start_at].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
-      end
+        def at_least_one_tag
+          exists_contition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                             .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                                                             .and(
+                                                               tagging_arel_table[:tag_id].in(
+                                                                 tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
+                                                               )
+                                                             )
 
-      if options[:end_at].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
-      end
+          if options[:start_at].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+          end
 
-      if options[:on].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:context].eq(options[:on]))
-      end
+          if options[:end_at].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+          end
 
-      if (owner = options[:owned_by]).present?
-        exists_contition = exists_contition.and(tagging_arel_table[:tagger_id].eq(owner.id))
-                                   .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
-      end
+          if options[:on].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:context].eq(options[:on]))
+          end
 
-      exists_contition
-    end
+          if (owner = options[:owned_by]).present?
+            exists_contition = exists_contition.and(tagging_arel_table[:tagger_id].eq(owner.id))
+                                               .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+          end
 
-    def order_conditions
-      order_by = []
-      if options[:order_by_matching_tag_count].present?
-        order_by << "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{at_least_one_tag.to_sql}) desc"
-      end
+          exists_contition
+        end
 
-      order_by << options[:order] if options[:order].present?
-      order_by.join(', ')
-    end
+        def order_conditions
+          order_by = []
+          if options[:order_by_matching_tag_count].present?
+            order_by << "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{at_least_one_tag.to_sql}) desc"
+          end
 
-    def alias_name(tag_list)
-      alias_base_name = taggable_model.base_class.name.downcase
-      taggings_context = options[:on] ? "_#{options[:on]}" : ''
+          order_by << options[:order] if options[:order].present?
+          order_by.join(', ')
+        end
 
-      taggings_alias = adjust_taggings_alias(
-          "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag_list.join('_'))}"
-       )
+        def alias_name(tag_list)
+          alias_base_name = taggable_model.base_class.name.downcase
+          taggings_context = options[:on] ? "_#{options[:on]}" : ''
 
-      taggings_alias
+          adjust_taggings_alias(
+            "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag_list.join('_'))}"
+          )
+        end
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/tagged_with_query/exclude_tags_query.rb

@@ -1,82 +1,85 @@
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  class ExcludeTagsQuery < QueryBase
-    def build
-      taggable_model.joins(owning_to_tagger)
-                    .where(tags_not_in_list)
-                    .having(tags_that_matches_count)
-                    .readonly(false)
-    end
-
-    private
-
-    def tags_not_in_list
-      return taggable_arel_table[:id].not_in(
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class ExcludeTagsQuery < QueryBase
+        def build
+          taggable_model.joins(owning_to_tagger)
+                        .where(tags_not_in_list)
+                        .having(tags_that_matches_count)
+                        .readonly(false)
+        end
+
+        private
+
+        def tags_not_in_list
+          taggable_arel_table[:id].not_in(
             tagging_arel_table
               .project(tagging_arel_table[:taggable_id])
               .join(tag_arel_table)
               .on(
-                  tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
-                  .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-                  .and(tags_match_type)
-                )
+                tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
+                .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                .and(tags_match_type)
+              )
           )
 
-        # FIXME: missing time scope, this is also missing in the original implementation
-    end
+          # FIXME: missing time scope, this is also missing in the original implementation
+        end
 
+        def owning_to_tagger
+          return [] if options[:owned_by].blank?
 
-    def owning_to_tagger
-      return [] unless options[:owned_by].present?
+          owner = options[:owned_by]
 
-      owner = options[:owned_by]
+          arel_join = taggable_arel_table
+                      .join(tagging_arel_table)
+                      .on(
+                        tagging_arel_table[:tagger_id].eq(owner.id)
+                        .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+                        .and(tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key]))
+                        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                      )
 
-      arel_join = taggable_arel_table
-        .join(tagging_arel_table)
-        .on(
-            tagging_arel_table[:tagger_id].eq(owner.id)
-            .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
-            .and(tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key]))
-            .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-          )
+          if options[:match_all].present?
+            arel_join = arel_join
+                        .join(tagging_arel_table, Arel::Nodes::OuterJoin)
+                        .on(
+                          match_all_on_conditions
+                        )
+          end
 
-      if options[:match_all].present?
-        arel_join = arel_join
-          .join(tagging_arel_table, Arel::Nodes::OuterJoin)
-          .on(
-            match_all_on_conditions
-          )
-      end
+          arel_join.join_sources
+        end
 
-      return arel_join.join_sources
-    end
+        def match_all_on_conditions
+          on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                         .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
 
-    def match_all_on_conditions
-      on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
-        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+          if options[:start_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+          end
 
-      if options[:start_at].present?
-        on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
-      end
+          if options[:end_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+          end
 
-      if options[:end_at].present?
-        on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
-      end
+          on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on])) if options[:on].present?
 
-      if options[:on].present?
-        on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on]))
-      end
+          on_condition
+        end
 
-      on_condition
-    end
+        def tags_that_matches_count
+          return [] if options[:match_all].blank?
 
-    def tags_that_matches_count
-      return [] unless options[:match_all].present?
+          taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
 
-      taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
-
-      tagging_arel_table[:taggable_id].count.eq(
-        tag_arel_table.project(Arel.star.count).where(tags_match_type)
-      )
+          tagging_arel_table[:taggable_id].count.eq(
+            tag_arel_table.project(Arel.star.count).where(tags_match_type)
+          )
+        end
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/tagged_with_query/query_base.rb

@@ -1,61 +1,69 @@
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  class QueryBase
-    def initialize(taggable_model, tag_model, tagging_model, tag_list, options)
-      @taggable_model = taggable_model
-      @tag_model      = tag_model
-      @tagging_model  = tagging_model
-      @tag_list       = tag_list
-      @options        = options
-    end
+# frozen_string_literal: true
 
-    private
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class QueryBase
+        def initialize(taggable_model, tag_model, tagging_model, tag_list, options)
+          @taggable_model = taggable_model
+          @tag_model      = tag_model
+          @tagging_model  = tagging_model
+          @tag_list       = tag_list
+          @options        = options
+        end
 
-    attr_reader :taggable_model, :tag_model, :tagging_model, :tag_list, :options
+        private
 
-    def taggable_arel_table
-      @taggable_arel_table ||= taggable_model.arel_table
-    end
+        attr_reader :taggable_model, :tag_model, :tagging_model, :tag_list, :options
 
-    def tag_arel_table
-      @tag_arel_table ||= tag_model.arel_table
-    end
+        def taggable_arel_table
+          @taggable_arel_table ||= taggable_model.arel_table
+        end
 
-    def tagging_arel_table
-      @tagging_arel_table ||=tagging_model.arel_table
-    end
+        def tag_arel_table
+          @tag_arel_table ||= tag_model.arel_table
+        end
 
-    def tag_match_type(tag)
-      matches_attribute = tag_arel_table[:name]
-      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+        def tagging_arel_table
+          @tagging_arel_table ||= tagging_model.arel_table
+        end
 
-      if options[:wild].present?
-        matches_attribute.matches("%#{escaped_tag(tag)}%", "!", ActsAsTaggableOn.strict_case_match)
-      else
-        matches_attribute.matches(escaped_tag(tag), "!", ActsAsTaggableOn.strict_case_match)
-      end
-    end
+        def tag_match_type(tag)
+          matches_attribute = tag_arel_table[:name]
+          matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
 
-    def tags_match_type
-      matches_attribute = tag_arel_table[:name]
-      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+          if options[:wild].present?
+            matches_attribute.matches("%#{escaped_tag(tag)}%", '!', ActsAsTaggableOn.strict_case_match)
+          else
+            matches_attribute.matches(escaped_tag(tag), '!', ActsAsTaggableOn.strict_case_match)
+          end
+        end
 
-      if options[:wild].present?
-        matches_attribute.matches_any(tag_list.map{|tag| "%#{escaped_tag(tag)}%"}, "!", ActsAsTaggableOn.strict_case_match)
-      else
-        matches_attribute.matches_any(tag_list.map{|tag| "#{escaped_tag(tag)}"}, "!", ActsAsTaggableOn.strict_case_match)
-      end
-    end
+        def tags_match_type
+          matches_attribute = tag_arel_table[:name]
+          matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
 
-    def escaped_tag(tag)
-      tag = tag.downcase unless ActsAsTaggableOn.strict_case_match
-      ActsAsTaggableOn::Utils.escape_like(tag)
-    end
+          if options[:wild].present?
+            matches_attribute.matches_any(tag_list.map do |tag|
+                                            "%#{escaped_tag(tag)}%"
+                                          end, '!', ActsAsTaggableOn.strict_case_match)
+          else
+            matches_attribute.matches_any(tag_list.map do |tag|
+                                            escaped_tag(tag).to_s
+                                          end, '!', ActsAsTaggableOn.strict_case_match)
+          end
+        end
+
+        def escaped_tag(tag)
+          tag = tag.downcase unless ActsAsTaggableOn.strict_case_match
+          ActsAsTaggableOn::Utils.escape_like(tag)
+        end
 
-    def adjust_taggings_alias(taggings_alias)
-      if taggings_alias.size > 75
-        taggings_alias = 'taggings_alias_' + Digest::SHA1.hexdigest(taggings_alias)
+        def adjust_taggings_alias(taggings_alias)
+          taggings_alias = "taggings_alias_#{Digest::SHA1.hexdigest(taggings_alias)}" if taggings_alias.size > 75
+          taggings_alias
+        end
       end
-      taggings_alias
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/tagged_with_query.rb

@@ -1,16 +1,22 @@
+# frozen_string_literal: true
+
 require_relative 'tagged_with_query/query_base'
 require_relative 'tagged_with_query/exclude_tags_query'
 require_relative 'tagged_with_query/any_tags_query'
 require_relative 'tagged_with_query/all_tags_query'
 
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  def self.build(taggable_model, tag_model, tagging_model, tag_list, options)
-    if options[:exclude].present?
-      ExcludeTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
-    elsif options[:any].present?
-      AnyTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
-    else
-      AllTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      def self.build(taggable_model, tag_model, tagging_model, tag_list, options)
+        if options[:exclude].present?
+          ExcludeTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        elsif options[:any].present?
+          AnyTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        else
+          AllTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        end
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
   module Taggable
-
     def taggable?
       false
     end
@@ -56,11 +57,10 @@ module ActsAsTaggableOn
 
     def acts_as_taggable_tenant(tenant)
       if taggable?
-        self.tenant_column = tenant
       else
         class_attribute :tenant_column
-        self.tenant_column = tenant
       end
+      self.tenant_column = tenant
 
       # each of these add context-specific methods and must be
       # called on each call of taggable_on
@@ -73,17 +73,17 @@ module ActsAsTaggableOn
 
     private
 
-      # Make a model taggable on specified contexts
-      # and optionally preserves the order in which tags are created
-      #
-      # Separate methods used above for backwards compatibility
-      # so that the original acts_as_taggable_on method is unaffected
-      # as it's not possible to add another argument to the method
-      # without the tag_types being enclosed in square brackets
-      #
-      # NB: method overridden in core module in order to create tag type
-      #     associations and methods after this logic has executed
-      #
+    # Make a model taggable on specified contexts
+    # and optionally preserves the order in which tags are created
+    #
+    # Separate methods used above for backwards compatibility
+    # so that the original acts_as_taggable_on method is unaffected
+    # as it's not possible to add another argument to the method
+    # without the tag_types being enclosed in square brackets
+    #
+    # NB: method overridden in core module in order to create tag type
+    #     associations and methods after this logic has executed
+    #
     def taggable_on(preserve_tag_order, *tag_types)
       tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
 

data/lib/acts_as_taggable_on/tagger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
   module Tagger
     def self.included(base)
@@ -13,7 +15,7 @@ module ActsAsTaggableOn
       #   class User < ActiveRecord::Base
       #     acts_as_tagger
       #   end
-      def acts_as_tagger(opts={})
+      def acts_as_tagger(opts = {})
         class_eval do
           owned_taggings_scope = opts.delete(:scope)
 
@@ -54,14 +56,16 @@ module ActsAsTaggableOn
       #
       # Example:
       #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
-      def tag(taggable, opts={})
+      def tag(taggable, opts = {})
         opts.reverse_merge!(force: true)
         skip_save = opts.delete(:skip_save)
         return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
 
-        fail 'You need to specify a tag context using :on' unless opts.key?(:on)
-        fail 'You need to specify some tags using :with' unless opts.key?(:with)
-        fail "No context :#{opts[:on]} defined in #{taggable.class}" unless opts[:force] || taggable.tag_types.include?(opts[:on])
+        raise 'You need to specify a tag context using :on' unless opts.key?(:on)
+        raise 'You need to specify some tags using :with' unless opts.key?(:with)
+        unless opts[:force] || taggable.tag_types.include?(opts[:on])
+          raise "No context :#{opts[:on]} defined in #{taggable.class}"
+        end
 
         taggable.set_owner_tag_list_on(self, opts[:on].to_s, opts[:with])
         taggable.save unless skip_save

data/lib/acts_as_taggable_on/tagging.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
-  class Tagging < ::ActiveRecord::Base #:nodoc:
+  class Tagging < ::ActiveRecord::Base # :nodoc:
     self.table_name = ActsAsTaggableOn.taggings_table
 
     DEFAULT_CONTEXT = 'tags'
@@ -19,7 +21,7 @@ module ActsAsTaggableOn
     validates_presence_of :context
     validates_presence_of :tag_id
 
-    validates_uniqueness_of :tag_id, scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
+    validates_uniqueness_of :tag_id, scope: %i[taggable_type taggable_id context tagger_id tagger_type]
 
     after_destroy :remove_unused_tags
 
@@ -29,8 +31,8 @@ module ActsAsTaggableOn
       if ActsAsTaggableOn.remove_unused_tags
         if ActsAsTaggableOn.tags_counter
           tag.destroy if tag.reload.taggings_count.zero?
-        else
-          tag.destroy if tag.reload.taggings.none?
+        elsif tag.reload.taggings.none?
+          tag.destroy
         end
       end
     end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
   module TagsHelper
     # See the wiki for an example using tag_cloud.
     def tag_cloud(tags, classes)
       return [] if tags.empty?
 
-      max_count = tags.sort_by(&:taggings_count).last.taggings_count.to_f
+      max_count = tags.max_by(&:taggings_count).taggings_count.to_f
 
       tags.each do |tag|
         index = ((tag.taggings_count / max_count) * (classes.size - 1))

data/lib/acts_as_taggable_on/utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This module is deprecated and will be removed in the incoming versions
 
 module ActsAsTaggableOn
@@ -9,7 +11,7 @@ module ActsAsTaggableOn
       end
 
       def using_postgresql?
-        connection && connection.adapter_name == 'PostgreSQL'
+        connection && %w[PostgreSQL PostGIS].include?(connection.adapter_name)
       end
 
       def using_mysql?
@@ -30,7 +32,7 @@ module ActsAsTaggableOn
 
       # escape _ and % characters in strings, since these are wildcards in SQL.
       def escape_like(str)
-        str.gsub(/[!%_]/) { |x| '!' + x }
+        str.gsub(/[!%_]/) { |x| "!#{x}" }
       end
     end
   end

data/lib/acts_as_taggable_on/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
-  VERSION = '8.1.0'
+  VERSION = '9.0.0'
 end

data/spec/support/database.rb

@@ -1,36 +1,46 @@
+# frozen_string_literal: true
+
 # set adapter to use, default is sqlite3
 # to use an alternative adapter run => rake spec DB='postgresql'
 db_name = ENV['DB'] || 'sqlite3'
-database_yml = File.expand_path('../../internal/config/database.yml', __FILE__)
+database_yml = File.expand_path('../internal/config/database.yml', __dir__)
 
-if File.exist?(database_yml)
+unless File.exist?(database_yml)
+  raise "Please create #{database_yml} first to configure your database. Take a look at: #{database_yml}.sample"
+end
 
-  ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.configurations = YAML.load_file(database_yml)
+ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), '../debug.log'))
+ActiveRecord::Base.logger.level = ENV['CI'] ? ::Logger::ERROR : ::Logger::DEBUG
+ActiveRecord::Migration.verbose = false
+if ActiveRecord.version >= Gem::Version.new('7.0.0.alpha2')
+  ActiveRecord.default_timezone = :utc
+else
   ActiveRecord::Base.default_timezone = :utc
-  ActiveRecord::Base.configurations = YAML.load_file(database_yml)
-  ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), '../debug.log'))
-  ActiveRecord::Base.logger.level = ENV['TRAVIS'] ? ::Logger::ERROR : ::Logger::DEBUG
-  config = ActiveSupport::HashWithIndifferentAccess.new(ActiveRecord::Base.configurations[db_name])
-
-  begin
-    ActiveRecord::Base.establish_connection(db_name.to_sym)
-    ActiveRecord::Base.connection
-  rescue
-    case db_name
-      when /mysql/
-        ActiveRecord::Base.establish_connection(config.merge('database' => nil))
-        ActiveRecord::Base.connection.create_database(config['database'], {charset: 'utf8', collation: 'utf8_unicode_ci'})
-      when 'postgresql'
-        ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
-        ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => 'utf8'))
-    end
+end
+config = if ActiveRecord.version >= Gem::Version.new('6.1.0')
+           ActiveRecord::Base.configurations.configs_for(env_name: db_name)
+         else
+           ActiveSupport::HashWithIndifferentAccess.new(ActiveRecord::Base.configurations[db_name])
+         end
 
-    ActiveRecord::Base.establish_connection(config)
+begin
+  ActiveRecord::Base.establish_connection(db_name.to_sym)
+  ActiveRecord::Base.connection
+rescue StandardError
+  case db_name
+  when /mysql/
+    ActiveRecord::Base.establish_connection(config.merge('database' => nil))
+    ActiveRecord::Base.connection.create_database(config['database'],
+                                                  { charset: 'utf8', collation: 'utf8_unicode_ci' })
+  when 'postgresql'
+    ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres',
+                                                         'schema_search_path' => 'public'))
+    ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => 'utf8'))
   end
 
-  require File.dirname(__FILE__) + '/../internal/db/schema.rb'
-  Dir[File.dirname(__dir__) + '/internal/app/models/*.rb'].each { |f| require f }
-
-else
-  fail "Please create #{database_yml} first to configure your database. Take a look at: #{database_yml}.sample"
+  ActiveRecord::Base.establish_connection(config)
 end
+
+require "#{File.dirname(__FILE__)}/../internal/db/schema.rb"
+Dir["#{File.dirname(__dir__)}/internal/app/models/*.rb"].each { |f| require f }