Handle UnknownAttributeError and put attributes to #unknown_attributes (

#23)

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## master
 
+- [PR #22](https://github.com/DmitryTsepelev/store_model/pull/22) Store unknown attributes in `#unknown_attributes` ([@DmitryTsepelev][])
+
 ## 0.4.1 (2019-08-31)
 
 - [PR #21](https://github.com/DmitryTsepelev/store_model/pull/21) Properly validate and handle nested models ([@DmitryTsepelev][])

README.md

@@ -82,10 +82,11 @@ product.save
 ## Documentation
 
 1. [Installation](./docs/installation.md)
-2. `StoreModel::Model` API:
+2. StoreModel::Model API:
   * [Validations](./docs/validations.md)
   * [Enums](./docs/enums.md)
   * [Nested models](./docs/nested_models.md)
+  * [Unknown attributes](./docs/unknown_attributes.md)
 3. [Array of stored models](./docs/array_of_stored_models.md)
 4. [Alternatives](./docs/alternatives.md)
 

docs/unknown_attributes.md

@@ -0,0 +1,14 @@
+# Unknown attributes
+
+Sometimes JSON structure changes and it contains more keys than attributes defined in your `StoreModel::Model` class. In such cases, "unknown" attributes can be found inside the `#unknown_attributes` hash:
+
+```ruby
+class Configuration
+  include StoreModel::Model
+
+  attribute :color, :string
+end
+
+configuration = Configuration.new(color: "red", archived: true)
+configuration.unknown_attributes # => { "archived" => true }
+```

lib/store_model/model.rb

@@ -39,5 +39,9 @@ def inspect
     def type_for_attribute(attribute)
       self.class.attribute_types[attribute.to_s]
     end
+
+    def unknown_attributes
+      @unknown_attributes ||= {}
+    end
   end
 end

lib/store_model/types/json_type.rb

@@ -18,11 +18,10 @@ def cast_value(value)
         when String then decode_and_initialize(value)
         when Hash then @model_klass.new(value)
         when @model_klass, nil then value
-        else
-          raise StoreModel::Types::CastError,
-                "failed casting #{value.inspect}, only String, " \
-                "Hash or #{@model_klass.name} instances are allowed"
+        else raise_cast_error(value)
         end
+      rescue ActiveModel::UnknownAttributeError => e
+        handle_unknown_attribute(value, e)
       end
 
       def serialize(value)
@@ -44,8 +43,25 @@ def changed_in_place?(raw_old_value, new_value)
       def decode_and_initialize(value)
         decoded = ActiveSupport::JSON.decode(value) rescue nil
         @model_klass.new(decoded) unless decoded.nil?
+      rescue ActiveModel::UnknownAttributeError => e
+        handle_unknown_attribute(decoded, e)
       end
       # rubocop:enable Style/RescueModifier
+
+      def raise_cast_error(value)
+        raise StoreModel::Types::CastError,
+              "failed casting #{value.inspect}, only String, " \
+              "Hash or #{@model_klass.name} instances are allowed"
+      end
+
+      def handle_unknown_attribute(value, exception)
+        attribute = exception.attribute.to_sym
+        value_symbolized = value.symbolize_keys
+
+        cast_value(value_symbolized.except(attribute)).tap do |configuration|
+          configuration.unknown_attributes[attribute.to_s] = value_symbolized[attribute]
+        end
+      end
     end
   end
 end

spec/store_model/types/json_type_spec.rb

@@ -27,24 +27,24 @@
   describe "#cast_value" do
     subject { type.cast_value(value) }
 
-    shared_examples "cast examples" do
+    shared_examples "for known attributes" do
       it { is_expected.to be_a(Configuration) }
       it("assigns attributes") { is_expected.to have_attributes(attributes) }
     end
 
-    context "when String is passed" do
-      let(:value) { ActiveSupport::JSON.encode(attributes) }
-      include_examples "cast examples"
-    end
-
     context "when Hash is passed" do
       let(:value) { attributes }
-      include_examples "cast examples"
+      include_examples "for known attributes"
+    end
+
+    context "when String is passed" do
+      let(:value) { ActiveSupport::JSON.encode(attributes) }
+      include_examples "for known attributes"
     end
 
     context "when Configuration instance is passed" do
       let(:value) { Configuration.new(attributes) }
-      include_examples "cast examples"
+      include_examples "for known attributes"
     end
 
     context "when nil is passed" do
@@ -63,6 +63,32 @@
         )
       end
     end
+
+    context "when some keys are not defined as attributes" do
+      shared_examples "for unknown attributes" do
+        it { is_expected.to be_a(Configuration) }
+
+        it("assigns attributes") { is_expected.to have_attributes(color: "red") }
+
+        it "assigns unknown_attributes" do
+          expect(subject.unknown_attributes).to eq(
+            "unknown_attribute" => "something", "one_more" => "anything"
+          )
+        end
+      end
+
+      let(:attributes) { { color: "red", unknown_attribute: "something", one_more: "anything" } }
+
+      context "when Hash is passed" do
+        let(:value) { attributes }
+        include_examples "for unknown attributes"
+      end
+
+      context "when String is passed" do
+        let(:value) { ActiveSupport::JSON.encode(attributes) }
+        include_examples "for unknown attributes"
+      end
+    end
   end
 
   describe "#serialize" do