rankmi-localization 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 788eabef0fae27b076f9824737c577751baa5d8bee4034a0e1ace9d2aecdc18b
+  data.tar.gz: '0109095f825a8a2e8bf0f28ec2739b233206ed27a09ba3c8d579cd97a4cf56c5'
+SHA512:
+  metadata.gz: 8cb4ea2088f0317b51ab81f0d1aa791996a77a3c01488313130066f05b1fd1a591f2a8cbe06958d0b9a8825c5f4bdfe5787456732bf8bc69786b1fc4d0299edd
+  data.tar.gz: 37091f2194cbe03fa99cb750c2f046c79f97dedf7c823c0a0e7c37e71a9941db268da89e7a7ecff50ab9e2f53bdf7ebfd0ca1190cd4acd7b5382bb1139c40715

data/README.md

@@ -0,0 +1,25 @@
+# Step 1:
+
+Run `matrix start databases` to create necessary databases to run this project
+
+# Step 2:
+
+Run `matrix local shell` and then run the following commands
+
+```shell
+bundle exec rake db:create
+bundle exec rake db:setup
+```
+
+# Step 3:
+
+You are all set!!
+
+If you want to run specs, feel free to run then using matrix
+`matrix local test`
+
+## More info
+
+If you create new environment variables and you intend to use them on Github Actions (this project doesn't use Drone, c'mon, everybody is tired of that red ribbon)
+
+Then you need to create the variables at the .env.test file too, because GH Actions consume them!

data/Rakefile

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'annotate'
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+Dir[File.join(__dir__, 'lib', 'tasks', '*.rake')].each { |file| load file }
+
+RSpec::Core::RakeTask.new(:spec)
+
+if ENV['RACK_ENV'] == 'development' || ENV['RAILS_ENV'] == 'development'
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+  task default: %i[spec rubocop]
+else
+  task default: %i[spec]
+end
+
+namespace :db do
+  desc 'Run migrations and annotate models for the dummy app'
+  task migrate_and_annotate: [:migrate] do
+    Dir.chdir('spec/dummy') do
+      # Check if there are any model files before running annotate
+      model_dir = File.join(Dir.pwd, 'app/models')
+      sh 'bundle exec annotate' if Dir.exist?(model_dir) && Dir[File.join(model_dir,
+                                                                          '**/*.rb')].any?
+    end
+  end
+end
+
+# Run this task automatically after db:migrate for the gem
+Rake::Task['db:migrate'].enhance do
+  Rake::Task['db:migrate_and_annotate'].invoke
+end

data/app/controllers/concerns/country_locale.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# callback para controlar locale según el country del usuario
+module CountryLocale
+  extend ActiveSupport::Concern
+  included do
+    around_action :switch_locale
+  end
+
+  COUNTRY_LOCALE = {
+    cl: 'es-cl',
+    mx: 'es-mx',
+    pe: 'es-pe',
+    ar: 'es-ar'
+  }.with_indifferent_access
+
+  def switch_locale(&action)
+    if current_user&.id
+      locale = locale_by_country(current_user&.country&.downcase)
+      I18n.with_locale(locale, &action)
+    else
+      I18n.with_locale('es-cl', &action)
+    end
+  end
+
+  def locale_by_country(country)
+    COUNTRY_LOCALE[country] || I18n.default_locale
+  end
+end

data/app/models/concerns/countriable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: countries
+#
+#  id          :bigint           not null, primary key
+#  code        :string(4)        not null
+#  name        :string(255)      not null
+#  nationality :string(255)
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+# Indexes
+#
+#  index_countries_on_code  (code) UNIQUE
+#  index_countries_on_name  (name) UNIQUE
+#
+module Countriable
+  extend ActiveSupport::Concern
+
+  included do
+    after_initialize :ensure_countriable_setup
+    setup_countriable
+  end
+
+  def ensure_countriable_setup
+    self.class.setup_countriable unless self.class.reflect_on_association(:country_model)
+  end
+
+  class_methods do
+    def setup_countriable
+      foreign_key = column_names.include?('country_code') ? :country_code : :country
+      return unless foreign_key.to_s.in?(column_names)
+
+      belongs_to(:country_model,
+                 class_name: 'Country',
+                 optional: true,
+                 primary_key: :code,
+                 foreign_key: foreign_key,
+                 inverse_of: name.demodulize.underscore.pluralize.to_sym)
+
+      validates(foreign_key,
+                inclusion: { in: ::ISO3166::Country.countries.map(&:alpha2) },
+                allow_blank: true)
+    end
+  end
+end

data/app/models/rankmi_localization/application_record.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: countries
+#
+#  id          :bigint           not null, primary key
+#  code        :string(4)        not null
+#  name        :string(255)      not null
+#  nationality :string(255)
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+# Indexes
+#
+#  index_countries_on_code  (code) UNIQUE
+#  index_countries_on_name  (name) UNIQUE
+#
+module RankmiLocalization
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    # establish_connection(:rankmi_localization)
+    # for some reason, command above doesn't work, we will use the command below for now
+    establish_connection Rails.configuration.database_configuration[Rails.env]['rankmi_localization']
+    connects_to database: { writing: :rankmi_localization, reading: :rankmi_localization }
+    # Override table name inference to exclude the module name
+    def self.table_name
+      return super if abstract_class?
+
+      @table_name ||= name.demodulize.underscore.pluralize
+    end
+  end
+end

data/app/models/rankmi_localization/country.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: countries
+#
+#  id          :bigint           not null, primary key
+#  code        :string(4)        not null
+#  name        :string(255)      not null
+#  nationality :string(255)
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+# Indexes
+#
+#  index_countries_on_code  (code) UNIQUE
+#  index_countries_on_name  (name) UNIQUE
+#
+
+module RankmiLocalization
+  class Country < RankmiLocalization::ApplicationRecord
+    # Validations
+    validates :code,
+              presence: true,
+              uniqueness: true,
+              length: { is: 2 },
+              format: { with: /\A[A-Z]{2}\z/ }
+    validates :name,
+              presence: true,
+              length: { maximum: 255 }
+    validates :code,
+              inclusion: { in: ::ISO3166::Country.countries.map(&:alpha2) },
+              allow_blank: true
+
+    # Callbacks
+    before_validation { code.upcase! if code.present? }
+
+    def self.[](code)
+      ::ISO3166::Country[code]
+    end
+  end
+end

data/app/models/rankmi_localization/location.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: countries
+#
+#  id          :bigint           not null, primary key
+#  code        :string(4)        not null
+#  name        :string(255)      not null
+#  nationality :string(255)
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+# Indexes
+#
+#  index_countries_on_code  (code) UNIQUE
+#  index_countries_on_name  (name) UNIQUE
+#
+
+module RankmiLocalization
+  class Location < RankmiLocalization::ApplicationRecord
+    # Associations
+    belongs_to :parent, class_name: 'Location', optional: true, inverse_of: :children
+    has_many :children,
+             class_name: 'Location',
+             foreign_key: :parent_id,
+             inverse_of: :parent,
+             dependent: :destroy
+
+    # Validations
+    validates :name, presence: true
+
+    # Constants
+    DIVISIONS = {
+      ar: { pais: 0, provincia: 1, departamento: 2 },
+      cl: { pais: 0, region: 1, provincia: 2, comuna: 3 },
+      pe: { pais: 0, departamento: 1, provincia: 2, distrito: 3 },
+      mx: { pais: 0, estado: 1, municipio: 2, ciudad: 3, colonia: 4 }
+    }.freeze
+
+    COUNTRIES = {
+      ar: 'Argentina',
+      cl: 'Chile',
+      pe: 'Perú',
+      mx: 'México'
+    }.freeze
+
+    # Scopes
+    scope :divisions_for,
+          lambda { |division, country: :cl, code: nil|
+            unscoped do
+              country_root = Location.country(country)
+              level = DIVISIONS.dig(country, division)
+              return Location.none unless country || level
+
+              tree = all.preload(children: [children: [children: :children]])
+                        .where("locations.path LIKE '?/%' AND locations.deep_level = ?",
+                               country_root.id,
+                               level)
+
+              if code.present?
+                nodes = tree.where(code: code)
+                node = nodes[0]
+
+                parent_node = nodes
+                while node&.parent.present?
+                  nodes = parent_node
+                  parent_node = {
+                    id: node.parent.id,
+                    name: node.parent.name,
+                    children: nodes
+                  }
+                  node = node.parent
+                end
+                tree = parent_node
+              end
+
+              tree
+            end
+          }
+
+    # Class methods
+    def self.country(country)
+      Rails.cache.fetch("Location::Country::#{country.upcase}") do
+        find_by(name: COUNTRIES[country.downcase.to_sym],
+                deep_level: deep_level_by_country(country, :pais),
+                parent_id: nil)
+      end
+    end
+
+    def self.deep_level_by_country(country, division)
+      DIVISIONS.dig(country.downcase.to_sym, division.downcase.to_sym)
+    end
+  end
+end

data/db/migrate/20241126054133_create_or_update_locations_on_rankmi_localization.rb

@@ -0,0 +1,85 @@
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+# frozen_string_literal: true
+
+class CreateOrUpdateLocationsOnRankmiLocalization < RankmiLocalization::Migration
+  def up
+    if table_exists?(:locations)
+      add_column(:locations, :code, :string) unless column_exists?(:locations, :code)
+      add_column(:locations, :deep_level, :integer) unless column_exists?(:locations, :deep_level)
+      unless column_exists?(:locations,
+                            :extra_vacation_days)
+        add_column(:locations,
+                   :extra_vacation_days,
+                   :decimal,
+                   default: '0.0')
+      end
+      unless column_exists?(:locations,
+                            :extreme_zone)
+        add_column(:locations,
+                   :extreme_zone,
+                   :boolean,
+                   null: false,
+                   default: false)
+      end
+      add_column(:locations, :lre_code, :string) unless column_exists?(:locations, :lre_code)
+      add_column(:locations, :name, :string, null: false, default: '') unless column_exists?(
+        :locations, :name
+      )
+      add_column(:locations, :parent_id, :bigint) unless column_exists?(:locations, :parent_id)
+      add_column(:locations, :path, :string) unless column_exists?(:locations, :path)
+      unless column_exists?(:locations, :created_at)
+        add_column(:locations,
+                   :created_at,
+                   :datetime,
+                   precision: 6,
+                   null: false,
+                   default: lambda {
+                              'CURRENT_TIMESTAMP'
+                            })
+      end
+      unless column_exists?(:locations, :updated_at)
+        add_column(:locations,
+                   :updated_at,
+                   :datetime,
+                   precision: 6,
+                   null: false,
+                   default: lambda {
+                              'CURRENT_TIMESTAMP'
+                            })
+      end
+
+      add_index(:locations, :parent_id, name: 'index_locations_on_parent_id') unless index_exists?(
+        :locations,
+        :parent_id,
+        name: 'index_locations_on_parent_id'
+      )
+    else
+      create_table(:locations) do |t|
+        t.string(:code)
+        t.datetime(:created_at, precision: 6, null: false, default: -> { 'CURRENT_TIMESTAMP' })
+        t.integer(:deep_level)
+        t.decimal(:extra_vacation_days, null: false, default: '0.0')
+        t.boolean(:extreme_zone, null: false, default: false)
+        t.string(:lre_code)
+        t.string(:name, null: false, default: '')
+        t.bigint(:parent_id)
+        t.string(:path)
+        t.datetime(:updated_at, precision: 6, null: false, default: -> { 'CURRENT_TIMESTAMP' })
+        t.index(:parent_id, name: 'index_locations_on_parent_id')
+      end
+    end
+  end
+
+  def down
+    return unless table_exists?(:locations)
+
+    remove_index(:locations, name: 'index_locations_on_parent_id') if index_exists?(
+      :locations,
+      :parent_id,
+      name: 'index_locations_on_parent_id'
+    )
+    drop_table(:locations)
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

data/db/migrate/20241202212837_create_countries_on_rankmi_localization.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateCountriesOnRankmiLocalization < RankmiLocalization::Migration
+  def up
+    create_table(:countries) do |t|
+      t.string(:code, null: false, limit: 4)
+      t.string(:name, null: false, limit: 255)
+      t.string(:nationality, limit: 255)
+      t.timestamps
+
+      t.index(:code, unique: true)
+      t.index(:name, unique: true)
+    end
+  end
+
+  def down
+    drop_table(:countries)
+  end
+end

data/lib/generators/rankmi_localization/install/install_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module RankmiLocalization
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      def copy_initializer
+        template('rankmi_localization_initializer.rb', 'config/initializers/rankmi_localization.rb')
+      end
+
+      # def copy_migrations_to_spec_folder
+      #   migrations_path = File.expand_path('../../../../db/migrate', __dir__)
+      #   destination = 'spec/db_setup'
+
+      #   Dir.glob("#{migrations_path}/*.rb").each do |migration|
+      #     migration_name = migration.split('_', 4).last # Extract migration name without timestamp
+      #     timestamp = Time.zone.now.strftime('%Y%m%d%H%M%S')
+      #     new_name = "#{timestamp}_#{migration_name}"
+
+      #     copy_file(migration, File.join(destination, new_name))
+      #     sleep(1) # Ensure unique timestamp for each file
+      #   end
+      # end
+
+      def copy_migrations_to_spec_folder
+        migrations_path = File.expand_path('../../../../db/migrate', __dir__)
+        destination = 'spec/db_setup'
+
+        Dir.glob("#{migrations_path}/*.rb").each do |migration|
+          copy_file(migration, File.join(destination, File.basename(migration)))
+        end
+      end
+
+      def install_notes
+        readme('README.md')
+      end
+    end
+  end
+end

data/lib/generators/rankmi_localization/install/templates/README.md

@@ -0,0 +1,4 @@
+
+# Congratulations!
+
+You have installed the `rankmi_localization` gem successfully.

data/lib/generators/rankmi_localization/install/templates/rankmi_localization_initializer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Use this file to configure the RankmiLocalization gem
+RankmiLocalization.configure do |config|
+  config.sync_tables = true
+end

data/lib/rankmi_localization/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RankmiLocalization
+  class Configuration
+    attr_reader :sync_tables
+
+    def initialize
+      self.sync_tables = true
+    end
+
+    def sync_tables=(value)
+      @sync_tables = Rails.env.production? || value
+    end
+
+    def validate!
+      true
+    end
+  end
+end

data/lib/rankmi_localization/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+module RankmiLocalization
+  class Engine < ::Rails::Engine
+    isolate_namespace RankmiLocalization
+
+    # initializer 'rankmi_localization.load_migrations' do
+    #   Rails.application.config.paths['db/migrate'] << root.join('db/migrate').to_s
+    # end
+  end
+end

data/lib/rankmi_localization/migration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module RankmiLocalization
+  class Migration < ActiveRecord::Migration[6.0]
+    def exec_migration(conn, direction)
+      return unless using_gem_database?
+
+      super
+    end
+
+    private
+
+    def using_gem_database?
+      current_database = ActiveRecord::Base.connection_config[:database]
+      target_database = Rails.application.config.database_configuration[Rails.env]['rankmi_localization']['database']
+      current_database == target_database
+    end
+  end
+end

data/lib/rankmi_localization/railtie.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RankmiLocalization
+  class Railtie < ::Rails::Railtie
+    railtie_name :rankmi_localization
+
+    rake_tasks do
+      Dir.glob("#{File.expand_path(__dir__)}/lib/tasks/**/*.rake").each do |f|
+        next if File.basename(f) == 'auto_annotate_models.rake'
+
+        load f
+      end
+    end
+
+    # Define aliases after Rails initialization
+    config.to_prepare do
+      unless Object.const_defined?(:Country)
+        Object.const_set(:Country,
+                         RankmiLocalization::Country)
+      end
+      unless Object.const_defined?(:Location)
+        Object.const_set(:Location,
+                         RankmiLocalization::Location)
+      end
+    end
+  end
+end

data/lib/rankmi_localization/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RankmiLocalization
+  VERSION = '0.1.6'
+end

data/lib/rankmi_localization.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rankmi_localization/engine'
+require 'rankmi_localization/configuration'
+require 'rankmi_localization/version'
+require 'rankmi_localization/migration'
+require 'rankmi_localization/railtie' if defined?(Rails)
+
+module RankmiLocalization
+  class Error < StandardError; end
+
+  class << self
+    def configure
+      Rails.logger.debug { "RankmiLocalization: Configuring with #{block_given? ? 'block' : 'no block'}" }
+      yield(configuration) if block_given?
+    end
+
+    def reset
+      Rails.logger.debug('RankmiLocalization: Resetting configuration')
+      @configuration = nil
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+      Rails.logger.debug { "RankmiLocalization: Current configuration -> #{@configuration.inspect}" }
+      @configuration
+    end
+  end
+end

data/lib/tasks/auto_annotate_models.rake

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+if Rails.env.development? || Rails.env.test?
+  require 'annotate'
+  task set_annotation_options: :environment do
+    Annotate.set_defaults(
+      'active_admin' => 'false',
+      'additional_file_patterns' => ['app/models/**/*.rb'], # Include all nested files
+      'routes' => 'false',
+      'models' => 'true',
+      'position_in_routes' => 'before',
+      'position_in_class' => 'before',
+      'position_in_test' => 'before',
+      'position_in_fixture' => 'before',
+      'position_in_factory' => 'before',
+      'position_in_serializer' => 'before',
+      'show_foreign_keys' => 'true',
+      'show_complete_foreign_keys' => 'false',
+      'show_indexes' => 'true',
+      'simple_indexes' => 'false',
+      'model_dir' => 'app/models',
+      'root_dir' => '',
+      'include_version' => 'false',
+      'require' => '',
+      'exclude_models' => 'true',
+      'exclude_tests' => 'false',
+      'exclude_fixtures' => 'false',
+      'exclude_factories' => 'false',
+      'exclude_serializers' => 'false',
+      'exclude_scaffolds' => 'true',
+      'exclude_controllers' => 'true',
+      'exclude_helpers' => 'true',
+      'exclude_sti_subclasses' => 'false',
+      'ignore_model_sub_dir' => 'false',
+      'ignore_columns' => nil,
+      'ignore_routes' => nil,
+      'ignore_unknown_models' => 'false',
+      'hide_limit_column_types' => 'integer,bigint,boolean',
+      'hide_default_column_types' => 'json,jsonb,hstore',
+      'skip_on_db_migrate' => 'false',
+      'format_bare' => 'true',
+      'format_rdoc' => 'false',
+      'format_yard' => 'false',
+      'format_markdown' => 'false',
+      'sort' => 'false',
+      'force' => 'false',
+      'frozen' => 'false',
+      'classified_sort' => 'true',
+      'trace' => 'false',
+      'wrapper_open' => nil,
+      'wrapper_close' => nil,
+      'with_comment' => 'true',
+      'exclude' => ['app/models/concerns/**/*']
+    )
+  end
+
+  Annotate.load_tasks
+end

data/lib/tasks/populate_countries.rake

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+namespace :db do
+  desc 'Populate countries table with all countries in the world'
+  task populate_countries: :environment do
+    countries_data = ISO3166::Country.all
+
+    countries_data.each do |country|
+      country_record = Country.find_or_initialize_by(code: country.alpha2)
+      country_record.assign_attributes(
+        name: country.name,
+        nationality: country.nationality || 'N/A'
+      )
+      country_record.save
+    end
+
+    puts 'Countries table has been successfully populated!' unless Rails.env.test?
+  end
+end

data/lib/tasks/run_spec_migrations.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+namespace :db do
+  desc 'Run migrations from spec/db_setup before tests'
+  task spec_migrate: :environment do
+    migrations_path = Rails.root.join('spec/db_setup')
+    puts("Running migrations from: #{migrations_path}")
+
+    ActiveRecord::MigrationContext.new(migrations_path.to_s, ActiveRecord::SchemaMigration).migrate
+    puts("Migrations successfully applied from #{migrations_path}")
+  rescue StandardError => e
+    puts("Error while running migrations: #{e.message}")
+    exit(1)
+  end
+end

data/lib/tasks/spec_migrations.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+namespace :db do
+  desc 'Create and migrate rankmi_localization test database'
+  task spec_rankmi_localization: :environment do
+    if Rails.env.test?
+      # Create and migrate primary database
+      ActiveRecord::Base.establish_connection(Rails.configuration.database_configuration['test']['primary'])
+      ActiveRecord::Tasks::DatabaseTasks.create_current
+      ActiveRecord::MigrationContext.new('db/migrate', ActiveRecord::SchemaMigration).migrate
+
+      # Create and migrate payroll database
+      ActiveRecord::Base.establish_connection(Rails.configuration.database_configuration['test']['payroll'])
+      ActiveRecord::Tasks::DatabaseTasks.create_current
+      ActiveRecord::MigrationContext.new('db/migrate', ActiveRecord::SchemaMigration).migrate
+
+      # Create and migrate rankmi_localization database
+      ActiveRecord::Base.establish_connection(Rails.configuration.database_configuration['test']['rankmi_localization'])
+      ActiveRecord::Tasks::DatabaseTasks.create(
+        Rails.configuration.database_configuration['test']['rankmi_localization']
+      )
+      ActiveRecord::MigrationContext.new('db/migrate', ActiveRecord::SchemaMigration).migrate
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: rankmi-localization
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- Pedro Naponoceno
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+description: One DB to find them
+email:
+- pedro.naponoceno@rankmi.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/controllers/concerns/country_locale.rb
+- app/models/concerns/countriable.rb
+- app/models/rankmi_localization/application_record.rb
+- app/models/rankmi_localization/country.rb
+- app/models/rankmi_localization/location.rb
+- db/migrate/20241126054133_create_or_update_locations_on_rankmi_localization.rb
+- db/migrate/20241202212837_create_countries_on_rankmi_localization.rb
+- lib/generators/rankmi_localization/install/install_generator.rb
+- lib/generators/rankmi_localization/install/templates/README.md
+- lib/generators/rankmi_localization/install/templates/rankmi_localization_initializer.rb
+- lib/rankmi_localization.rb
+- lib/rankmi_localization/configuration.rb
+- lib/rankmi_localization/engine.rb
+- lib/rankmi_localization/migration.rb
+- lib/rankmi_localization/railtie.rb
+- lib/rankmi_localization/version.rb
+- lib/tasks/auto_annotate_models.rake
+- lib/tasks/populate_countries.rake
+- lib/tasks/run_spec_migrations.rake
+- lib/tasks/spec_migrations.rake
+homepage: https://github.com/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/
+  source_code_uri: https://github.com/
+  changelog_uri: https://github.com//blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: One DB to rule them all
+test_files: []