address_concern 2.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd8e4df80024c5fc3a3bc5984003e412615c3d6345d8408d17859e088183e7f2
-  data.tar.gz: eda7df98ac44d1ecc07c7e5a0f3c4afe3c93baa53378b31cdeab6d93a19d6d34
+  metadata.gz: bcde48cb5114abd702acfe50d80c0f9d1a384faa94b750627a0b5fe17a6d1fc4
+  data.tar.gz: 5b049ab69ee5882d7747b5de0a6de40ef41aca78b3a5c565e2328c0bac87fac9
 SHA512:
-  metadata.gz: a09d2db18101b7b407e52481559cefd69ae17b06384e448e92b160c939d785045725e3c768156a264af182087f1a11a77f1ddc0f5b9e3a9f3202b6cfdce8d719
-  data.tar.gz: 7ba89fd64d9f910fe77e5b807f335c6923ca80289549a6c43afe435ed4cbad699196c75f2415f8479b474e63f86943764e881b475e1e7cb2a76fcbbd5f88ec40
+  metadata.gz: 35e52d1a95952bb73d9a6267ff4e1a59ca10b311f8e69a4906110eb09a4c21b4cd2e4c5d3c5e08899d843ab5f919a77960dcb2775f01ae729bcc8b473752f643
+  data.tar.gz: ac471eda04dc70ad516b9e6f79179a17b31f54ede686e504266d1c56e1da1014bb21877d27ea3c789675f6bb6ad7bef4102b5b52c3d71d0498de5bf9b0596622

data/.tool-versions

@@ -0,0 +1,2 @@
+# ruby 2.7.4
+ruby 3.1.2

data/Changelog.md

@@ -0,0 +1,27 @@
+## 3.0.0
+
+Breaking changes:
+
+- Rename `.address_attributes`, `#address_lines`, … to something less ambiguous so it's clear whether we're talking about street address or all address attributes
+    - Rename .address_attr_names  -> .street_address_attr_names
+    - Rename #address_lines       -> #street_address_lines
+
+    It was confusing having .address_attributes and #address_attributes referring to completely
+    different sets of attributes.
+
+- Change the default value for `street_address.attributes` config to a more strict Regex pattern to avoid
+  matching `'foo_address'`: `column_names.grep(/^address$|^address_\d$/)`
+
+Fixes:
+
+- Fix `.states_for_country` to always return a `Carmen::RegionCollection` rather than sometimes a
+- plain Array `[]`, so that we won't get an error if we try to call `coded` on the returned collection.
+
+- Fix error with rails 5.2
+
+Added:
+
+- Add experimental support for `:on_unknown` config and state validation (added
+    `validate_state_for_country`)
+
+

data/address_concern.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'active_record_ignored_attributes' # for be_same_as
   s.add_development_dependency 'rspec'
+  s.add_development_dependency 'shoulda-matchers'
   s.add_development_dependency 'sqlite3'
   #s.add_development_dependency 'mysql2', '~>0.2.11'
 

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  activerecord:
+    errors:
+      messages:
+        # state_not_in_list: "must be one of the valid options for %{country_name}: %{states_for_country}"
+        state_not_in_list: "is not a valid option for %{country_name}"

data/lib/address_concern/address.rb

@@ -24,19 +24,6 @@ module Address
         }
         options = options.deep_symbolize_keys
         default_config = {
-          state: {
-            #normalize: false,
-            #validate: false,
-
-            code_attribute: column_for_attribute(:state_code).yield_self(&not_null)&.name ||
-                           (column_for_attribute(:state).yield_self(&not_null)&.name unless options.dig(:state, :name_attribute).to_s == 'state'),
-
-            name_attribute: column_for_attribute(:state_name).yield_self(&not_null)&.name ||
-                           (column_for_attribute(:state).yield_self(&not_null)&.name unless options.dig(:state, :code_attribute).to_s == 'state'),
-
-            on_unknown: ->(value, name_or_code) { },
-          },
-
           country: {
             #normalize: false,
             #validate: false,
@@ -50,15 +37,29 @@ module Address
             name_attribute: column_for_attribute(:country_name).yield_self(&not_null)&.name ||
                            (column_for_attribute(:country).yield_self(&not_null)&.name unless options.dig(:country, :code_attribute).to_s == 'country'),
 
-            on_unknown: ->(value, name_or_code) { },
+            on_unknown: ->(record, name_or_code, value) { },
           },
 
-          address: {
+          state: {
+            #normalize: false,
+            #validate: false,
+
+            code_attribute: column_for_attribute(:state_code).yield_self(&not_null)&.name ||
+                           (column_for_attribute(:state).yield_self(&not_null)&.name unless options.dig(:state, :name_attribute).to_s == 'state'),
+
+            name_attribute: column_for_attribute(:state_name).yield_self(&not_null)&.name ||
+                           (column_for_attribute(:state).yield_self(&not_null)&.name unless options.dig(:state, :code_attribute).to_s == 'state'),
+
+            on_unknown: ->(record, name_or_code, carmen_country, value) { },
+            debug_unknown: false
+          },
+
+          street_address: {
             #normalize: false,
             #validate: false,
 
             # Try to auto-detect address columns
-            attributes: column_names.grep(/address$|^address_\d$/),
+            attributes: column_names.grep(/^address$|^address_\d$/),
           }
         }
         @acts_as_address_config = config = {
@@ -141,24 +142,25 @@ module Address
 
       #─────────────────────────────────────────────────────────────────────────────────────────────
 
-      def address_attr_config
-        @acts_as_address_config[:address] || {}
+      def street_address_attr_config
+        if @acts_as_address_config[:address]
+          raise "The :address config key has been renamed to :street_address"
+        end
+        @acts_as_address_config[:street_address] || {}
       end
 
-      # TODO: rename to something different than the same name as #address_attributes, like
-      # street_address_attr_names
-      def address_attributes
-        Array(address_attr_config[:attributes]).map(&:to_sym)
+      def street_address_attr_names
+        Array(street_address_attr_config[:attributes]).map(&:to_sym)
       end
 
       # Address line 1
-      def address_attribute
-        address_attributes[0]
+      def street_address_attribute
+        street_address_attr_names[0]
       end
 
-      def multi_line_address?
-        address_attributes.size == 1 && (
-          column = column_for_attribute(address_attribute)
+      def multi_line_street_address?
+        street_address_attr_names.size == 1 && (
+          column = column_for_attribute(street_address_attribute)
           column.type == :text
         )
       end
@@ -168,7 +170,7 @@ module Address
       # AKA configured_address_attributes
       def address_attr_names
         [
-          *address_attributes,
+          *street_address_attr_names,
           :city,
           state_name_attribute,
           state_code_attribute,
@@ -180,18 +182,22 @@ module Address
     end
 
     #═════════════════════════════════════════════════════════════════════════════════════════════════
-    # Customizable validation (to add?)
+    # Customizable validation (part 1 of 2)
+    # TODO: Finish adding some optional reasonable default validations
 
     #validates_presence_of :address
     #validates_presence_of :state, if: :state_required?
     #validates_presence_of :country
 
+    validate :validate_state_for_country, if: -> { state_config[:validate_code] }
+
     #═════════════════════════════════════════════════════════════════════════════════════════════════
     # Attributes
 
     def _assign_attributes(attributes)
       attributes = attributes.symbolize_keys
       attributes = reorder_language_attributes(attributes)
+      attributes = attributes.stringify_keys
       super(attributes)
     end
 
@@ -215,7 +221,7 @@ module Address
 
     # TODO: automatically normalize if attribute_normalizer/normalizy gem is loaded? add a config option to opt out?
     #normalize_attributes :city, :state, :postal_code, :country
-    #normalize_attribute  *address_attributes, with: [:cleanlines, :strip]
+    #normalize_attribute  *street_address_attr_names, with: [:cleanlines, :strip]
 
     #═════════════════════════════════════════════════════════════════════════════════════════════════
     # Country & State (Carmen + custom)
@@ -386,7 +392,7 @@ module Address
         if (country = self.class.find_carmen_country_by_code(value))
           set_country_from_carmen_country(country)
         else
-          country_config[:on_unknown].(value, :code)
+          on_unknown = country_config[:on_unknown]&.(self, :code, value)
           write_attribute(self.class.country_code_attribute, value) if self.class.country_code_attribute
         end
       end
@@ -413,7 +419,7 @@ module Address
         if (country = self.class.find_carmen_country_by_name(value))
           set_country_from_carmen_country(country)
         else
-          country_config[:on_unknown].(value, :name)
+          on_unknown = country_config[:on_unknown]&.(self, :name, value)
           write_attribute(self.class.country_name_attribute, value) if self.class.country_name_attribute
         end
       end
@@ -458,9 +464,15 @@ module Address
         if carmen_country && (state = self.class.find_carmen_state_by_code(carmen_country, value))
           set_state_from_carmen_state(state)
         else
-          #puts carmen_country ? "unknown state code '#{value}'" : "can't find state without country"
-          state_config[:on_unknown].(value, :code)
-          write_attribute(self.class.state_code_attribute, value) if self.class.state_code_attribute
+          if state_config[:debug_unknown]
+            puts carmen_country ? "unknown state code '#{value}'. Valid options: #{states_for_country_str}" : "can't find state without country"
+          end
+          on_unknown = state_config[:on_unknown]&.(self, :code, carmen_country, value)
+          if on_unknown == :find_by_name && carmen_country && (state = self.class.find_carmen_state_by_name(carmen_country, value))
+            set_state_from_carmen_state(state)
+          else
+            write_attribute(self.class.state_code_attribute, value) if self.class.state_code_attribute
+          end
         end
       end
     end
@@ -491,7 +503,7 @@ module Address
           set_state_from_carmen_state(state)
         else
           #puts carmen_country ? "unknown state name '#{name}'" : "can't find state without country"
-          state_config[:on_unknown].(value, :name)
+          on_unknown = state_config[:on_unknown]&.(self, :name, carmen_country, value)
           write_attribute(self.class.state_name_attribute, value) if self.class.state_name_attribute
         end
       end
@@ -515,8 +527,11 @@ module Address
     # It is not required in the postal address for all countries, however. If you only want to show it
     # if it's required in the postal address, you can make it conditional based on
     # state_included_in_postal_address?.
+    # @return [Carmen::RegionCollection]
     def self.states_for_country(country)
-      return [] unless country
+      empty_set = Carmen::RegionCollection.new([])
+      return empty_set unless country
+
       country = find_carmen_country!(country)
 
       has_states_at_level_1 = country.subregions.any? { |region|
@@ -540,7 +555,7 @@ module Address
       #  # In 2016 what had been 27 regions was reduced to 18.
       #  # France is divided into 18 administrative regions, including 13 metropolitan regions and 5 overseas regions.
       #  # https://en.wikipedia.org/wiki/ISO_3166-2:FR
-      #  []
+      #  empty_set
       elsif has_states_at_level_1
         country.subregions
       else
@@ -669,18 +684,24 @@ module Address
     #════════════════════════════════════════════════════════════════════════════════════════════════════
     # Street address / Address lines
 
+    def street_address_attributes
+      attributes_slice(
+        *self.class.street_address_attr_names
+      )
+    end
+
     # Attribute alias for street address line 1
-    #if address_attribute
-    #  unless :address == address_attribute
-    #    alias_attribute :address, :"#{address_attribute}"
+    #if street_address_attribute
+    #  unless :street_address == street_address_attribute
+    #    alias_attribute :street_address, :"#{street_address_attribute}"
     #  end
     #end
 
-    def address_lines
-      if self.class.multi_line_address?
+    def street_address_lines
+      if self.class.multi_line_street_address?
         address.to_s.cleanlines.to_a
       else
-        self.class.address_attributes.map do |attr_name|
+        self.class.street_address_attr_names.map do |attr_name|
           send attr_name
         end
       end
@@ -693,7 +714,7 @@ module Address
     def lines
       [
         #name,
-        *address_lines,
+        *street_address_lines,
         city_line,
         country_name,
       ].reject(&:blank?)
@@ -746,7 +767,7 @@ module Address
     def parts
       [
         #name,
-        *address_lines,
+        *street_address_lines,
         city,
         state_name,
         postal_code,
@@ -775,6 +796,33 @@ module Address
     end
 
     #─────────────────────────────────────────────────────────────────────────────────────────────────
+  end # included do
+
+  #═════════════════════════════════════════════════════════════════════════════════════════════════
+  # Customizable validation (part 2 of 2)
+  # Defining here rather than in included block, so that it is actually defined on the module, which
+  # gives the consumer more flexibility on how to reuse the validation code. You can, for example,
+  # do this:
+  #
+  #    validate \
+  #    def validate_state_for_country
+  #      return unless addressable.is_a?(User)
+  #
+  #      super
+  #    end
+
+  def validate_state_for_country
+    return unless country_with_states?
+    return unless state_code
+    return if states_for_country.map(&:code).include? state_code
+
+    errors.add self.class.state_code_attribute, :state_not_in_list, country_name: country_name, states_for_country: states_for_country_str
+    # puts %(errors.messages=\n#{(errors.messages).pretty_inspect.indent(4)})
+  end
+
+  def states_for_country_str
+    return unless country_with_states?
+    states_for_country.map(&:code).join(', ')
   end
 end
 end

data/lib/address_concern/version.rb

@@ -1,5 +1,5 @@
 module AddressConcern
   def self.version
-    "2.1.1"
+    "3.0.0"
   end
 end

data/lib/address_concern.rb

@@ -2,7 +2,7 @@ require 'rails'
 require 'carmen'
 require 'active_record'
 
-Carmen.i18n_backend.append_locale_path File.join(File.dirname(__FILE__), '../config/locale/overlay/en')
+Carmen.i18n_backend.append_locale_path File.join(File.dirname(__FILE__), '../config/locales/overlay/en')
 
 require 'zeitwerk'
 loader = Zeitwerk::Loader.for_gem
@@ -22,3 +22,13 @@ require 'address_concern/version'
 #pp loader.autoloads
 loader.eager_load
 #require_relative '../app/models/address_concern/address'
+
+# When used in a Rails app, this isn't needed because the engine will add its locale load paths, but
+# when not using Rails, including from our tests, the engine isn't loaded.
+I18n.load_path.unshift(
+  *Dir.glob(
+    x=File.expand_path(
+      File.join(%w[.. config locales *.yml]), File.dirname(__FILE__)
+    )
+  )
+)

data/spec/models/acts_as_address_spec.rb

@@ -50,15 +50,15 @@ describe 'acts_as_address' do
   describe 'address lines' do
     describe Address do
       it do
-        expect(klass.multi_line_address?).to eq true
-        expect(klass.address_attributes).to eq [:address]
+        expect(klass.multi_line_street_address?).to eq true
+        expect(klass.street_address_attr_names).to eq [:address]
       end
     end
 
     describe AddressWithSeparateAddressColumns do
       it do
-        expect(klass.multi_line_address?).to eq false
-        expect(klass.address_attributes).to eq [:address_1, :address_2, :address_3]
+        expect(klass.multi_line_street_address?).to eq false
+        expect(klass.street_address_attr_names).to eq [:address_1, :address_2, :address_3]
       end
     end
   end

data/spec/models/address_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Address do
+describe Address, type: :model do
   def klass
     described_class
   end
@@ -213,16 +213,74 @@ describe Address do
 
   #═════════════════════════════════════════════════════════════════════════════════════════════════
 
-  describe 'setting state by name' do
-    context "simple" do
-      subject { Address.new(state: 'FL', country_name: 'United States') }
-      it { expect(subject.state_code).to eq('FL') }
+  describe 'setting state' do
+    # Uses find_carmen_state, which finds by name, falling back to finding by code.
+    describe 'setting state_name_attribute' do
+      before {
+        expect(Address.state_code_attribute).to eq :state_code
+        expect(Address.state_name_attribute).to eq :state
+      }
+
+      context "setting state_name_attribute to code" do
+        subject { Address.new(state: 'FL', country_name: 'United States') }
+        it { expect(subject.state_code).to eq('FL') }
+      end
+
+      context "setting state_name_attribute to name" do
+        subject { Address.new(state: 'Florida', country_name: 'United States') }
+        it { expect(subject.state_code).to eq('FL') }
+      end
     end
 
-    context "setting to name instead of code" do
-      subject { Address.new(state: 'Florida', country_name: 'United States') }
-      # Uses find_carmen_state, which finds by name, falling back to finding by code.
-      it { expect(subject.state_code).to eq('FL') }
+    # Unlike {state_name_attribute}=, which falls back to finding by code, {state_code_attribute}=
+    # _only_ looks up by code by default.
+    describe 'setting state_code_attribute' do
+      subject { Address.new(state_code: input, country_name: 'United States') }
+
+      before {
+        expect(Address.state_code_attribute).to eq :state_code
+        expect(Address.state_name_attribute).to eq :state
+
+      }
+      around(:example) { |example|
+        validate_code = Address.state_config[:validate_code]
+        Address.state_config[:validate_code] = true
+        example.run
+        Address.state_config[:validate_code] = validate_code
+      }
+
+      context "setting state_code_attribute to code" do
+        let(:input) { 'FL' }
+        it { expect(subject.state_code).to eq(input) }
+        it { expect(subject.carmen_state&.code).to eq('FL') }
+        it { expect(subject).to allow_values(input).for(:state_code) }
+      end
+
+      context "setting state_code_attribute to name: doesn't find by default" do
+        let(:input) { 'Florida' }
+        subject { Address.new(state_code: input, country_name: 'United States') }
+        it { expect(subject.state_code).to eq(input) }
+        it { expect(subject.carmen_state&.code).to eq(nil) }
+        it { expect(subject).to_not allow_values(input).for(:state_code).with_message('is not a valid option for United States') }
+
+        context "when state_config[:on_unknown] returns :find_by_name" do
+          before {
+            @orig = Address.state_config[:on_unknown]
+            Address.state_config[:on_unknown] = Proc.new { :find_by_name }
+          }
+          after { Address.state_config[:on_unknown] = @orig }
+          it { expect(subject.carmen_state&.code).to eq('FL') }
+          it { expect(subject.state_code).to eq('FL') }
+          it { expect(subject).to allow_values(input).for(:state_code) }
+        end
+      end
+    end
+  end
+
+  #═════════════════════════════════════════════════════════════════════════════════════════════════
+  describe 'validations' do
+    it do
+      expect(AddressConcern::Address.instance_method(:validate_state_for_country)).to be_a UnboundMethod
     end
   end
 
@@ -254,14 +312,14 @@ describe Address do
   describe 'address, address_lines' do
     describe Address do
       it do
-        expect(klass.multi_line_address?).to eq true
+        expect(klass.multi_line_street_address?).to eq true
 
         address = klass.new(address: str = 'Line 1')
         expect(address.address).to eq str
 
         address = klass.new(address: str = "Line 1\nLine 2\nLine 3")
         expect(address.address).to eq str
-        expect(address.address_lines).to eq [
+        expect(address.street_address_lines).to eq [
           'Line 1',
           'Line 2',
           'Line 3',
@@ -271,7 +329,7 @@ describe Address do
 
     describe AddressWithSeparateAddressColumns do
       it do
-        expect(klass.multi_line_address?).to eq false
+        expect(klass.multi_line_street_address?).to eq false
 
         address = klass.new(
           address_1: 'Line 1',
@@ -281,7 +339,7 @@ describe Address do
         expect(address.address_1).to eq 'Line 1'
         expect(address.address_2).to eq 'Line 2'
         expect(address.address_3).to eq 'Line 3'
-        expect(address.address_lines).to eq [
+        expect(address.street_address_lines).to eq [
           'Line 1',
           'Line 2',
           'Line 3',
@@ -368,6 +426,7 @@ describe Address do
     end
     context "when address has a state name instead of code entered for state_name, and state is for different country" do
       let(:user) { User.create }
+      # Internally, it sees: unknown state code 'FL'
       subject { user.build_physical_address(address: '123', city: 'Ocala', state_code: 'FL', country_name: 'Denmark') }
       it do
         expect(subject.state_code).         to eq('FL')
@@ -412,6 +471,7 @@ describe Address do
     it { expect(Address.new(country: 'United States').states_for_country.map(&:name)).to include 'Puerto Rico' }
     it { expect(Address.new(country: 'South Africa').states_for_country.map(&:name)).to include 'Mpumalanga' }
     it { expect(Address.new(country: 'Kenya').states_for_country.typed('province')).to be_empty }
+    it { expect(Address.new(country: 'Kenya').states_for_country.typed('province')).to be_empty }
     # At the time of this writing, it doesn't look like Carmen has been updated to
     # include the 47 counties listed under https://en.wikipedia.org/wiki/ISO_3166-2:KE.
     #it { Address.new(country: 'Kenya').states_for_country.map(&:name).should include 'Nyeri' }
@@ -448,6 +508,26 @@ describe Address do
     it { expect(Address.new(country_name: 'France').state_options.map(&:name)).to include 'Auvergne-Rhône-Alpes' }
     #it { Address.new(country: 'France').state_options.size.should eq 18 }
     #it { Address.new(country: 'France').state_options.map(&:name).should include 'Auvergne-Rhône-Alpes' }
+
+    context 'for a country without states data (Aruba)' do
+      subject { Address.new(country_name: 'Aruba') }
+      it do
+        expect(subject.states_for_country).to be_empty
+        expect(subject.states_for_country).to be_a Carmen::RegionCollection
+        expect(subject.states_for_country.coded('Roo')).to eq nil
+        expect(subject.country_with_states?).to eq false
+      end
+    end
+
+    context 'with an invalid country code (ZZ)' do
+      subject { Address.new(country_code: 'ZZ') }
+      it do
+        expect(subject.states_for_country).to be_empty
+        expect(subject.states_for_country).to be_a Carmen::RegionCollection
+        expect(subject.states_for_country.coded('Roo')).to eq nil
+        expect(subject.country_with_states?).to eq false
+      end
+    end
   end
 
   #═════════════════════════════════════════════════════════════════════════════════════════════════

data/spec/support/shoulda_matchers.rb

@@ -0,0 +1,8 @@
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+
+    with.library :active_record
+    with.library :active_model
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: address_concern
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Paul Campbell
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-21 00:00:00.000000000 Z
+date: 2022-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -123,6 +123,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -148,8 +162,9 @@ files:
 - ".document"
 - ".gitignore"
 - ".rspec"
-- ".ruby-version"
+- ".tool-versions"
 - CHANGELOG
+- Changelog.md
 - Gemfile
 - LICENSE.txt
 - Rakefile
@@ -158,7 +173,8 @@ files:
 - address_concern.gemspec
 - bin/console
 - config/address_concern.rb
-- config/locale/overlay/en/id.yml
+- config/locales/en.yml
+- config/locales/overlay/en/id.yml
 - lib/address_concern.rb
 - lib/address_concern/address.rb
 - lib/address_concern/address_associations.rb
@@ -188,6 +204,7 @@ files:
 - spec/support/models/employee.rb
 - spec/support/models/user.rb
 - spec/support/schema.rb
+- spec/support/shoulda_matchers.rb
 - tmp/.gitkeep
 homepage: http://github.com/TylerRick/address_concern
 licenses:
@@ -208,7 +225,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: A reusable Address model for your Rails apps

data/.ruby-version

@@ -1 +0,0 @@
-ruby-2.7.4