feat: JSON and YAML migration (Mapping -> Serializable)

shard.yml

@@ -1,14 +1,10 @@
 name: active-model
-version: 2.0.2
+version: 2.1.0
 
 dependencies:
   http-params-serializable:
     github: vladfaust/http-params-serializable
     version: ~> 0.3
-  json_mapping:
-    github: crystal-lang/json_mapping.cr
-  yaml_mapping:
-    github: crystal-lang/yaml_mapping.cr
 
 development_dependencies:
   ameba:

spec/model_spec.cr

@@ -335,10 +335,10 @@ describe ActiveModel::Model do
   describe "serialization" do
     it "should support to_json" do
       i = Inheritance.new
-      i.to_json.should eq "{\"boolean\":true,\"string\":\"hello\",\"integer\":45}"
+      JSON.parse(i.to_json).should eq JSON.parse("{\"boolean\":true,\"string\":\"hello\",\"integer\":45}")
 
       i.no_default = "test"
-      i.to_json.should eq "{\"boolean\":true,\"string\":\"hello\",\"integer\":45,\"no_default\":\"test\"}"
+      JSON.parse(i.to_json).should eq JSON.parse("{\"boolean\":true,\"string\":\"hello\",\"integer\":45,\"no_default\":\"test\"}")
     end
   end
 

src/active-model/model.cr

@@ -1,20 +1,32 @@
-require "http/params"
 require "json"
-require "json_mapping"
 require "yaml"
-require "yaml_mapping"
-require "http-params-serializable/ext"
 
+require "http/params"
+require "http-params-serializable/ext"
 require "./http-params"
 
 abstract class ActiveModel::Model
+  include JSON::Serializable
+  include YAML::Serializable
+
   # :nodoc:
   FIELD_MAPPINGS = {} of Nil => Nil
 
   module Missing
     extend self
   end
 
+  # Stub methods to prevent compiler errors
+  def apply_defaults; end
+
+  def changed?; end
+
+  def clear_changes_information; end
+
+  def changed_attributes; end
+
+  protected def validation_error; end
+
   macro inherited
     # Macro level constants
 
@@ -38,25 +50,14 @@ abstract class ActiveModel::Model
       __customize_orm__
       {% unless @type.abstract? %}
       __track_changes__
-      __map_json__
       __create_initializer__
       __getters__
       __nilability_validation__
+      __map_json__
       {% end %}
     end
   end
 
-  # Stub methods to prevent compiler errors
-  def apply_defaults; end
-
-  def changed?; end
-
-  def clear_changes_information; end
-
-  def changed_attributes; end
-
-  protected def validation_error; end
-
   # :nodoc:
   macro __process_attributes__
     {% klasses = @type.ancestors %}
@@ -105,6 +106,8 @@ abstract class ActiveModel::Model
       {% end %}
     end
 
+    # # Methods that return attributes
+
     # Returns a Hash of all the attribute values
     def attributes
       {
@@ -141,6 +144,7 @@ abstract class ActiveModel::Model
       } {% if PERSIST.empty? %} of Nil => Nil {% end %}
     end
 
+    # Deserialize from JSON if value is available in the payload
     def assign_attributes(
       {% for name, opts in FIELDS %}
         {{name.id}} : {{opts[:klass]}} | Missing = Missing,
@@ -280,12 +284,15 @@ abstract class ActiveModel::Model
       apply_defaults
     end
 
-    # Override the map json
+    # Setters
     {% for name, opts in FIELDS %}
       # {{name}} setter
       def {{name}}=(value : {{opts[:klass]}})
         if !@{{name}}_changed && @{{name}} != value
+          @[JSON::Field(ignore: true)]
+          @[YAML::Field(ignore: true)]
           @{{name}}_changed = true
+
           @{{name}}_was = @{{name}}
         end
         {% if SETTERS[name] %}
@@ -302,127 +309,86 @@ abstract class ActiveModel::Model
   # :nodoc:
   # Adds the from_json method
   macro __map_json__
-    {% if HAS_KEYS[0] && !PERSIST.empty? %}
-      JSON.mapping(
-        {% for name, opts in PERSIST %}
-          {% if opts[:converter] %}
-            {{name}}: { type: {{opts[:type_signature]}}, setter: false, converter: {{opts[:converter]}} },
-          {% else %}
-            {{name}}: { type: {{opts[:type_signature]}}, setter: false },
+    def after_initialize(trusted : Bool)
+      if !trusted
+        {% for name, opts in FIELDS %}
+          {% if !opts[:mass_assign] %}
+            @{{name}} = nil
           {% end %}
         {% end %}
-      )
-
-      # :nodoc:
-      def initialize(%pull : ::JSON::PullParser, trusted = false)
-        previous_def(%pull)
-        if !trusted
-          {% for name, opts in FIELDS %}
-            {% if !opts[:mass_assign] %}
-              @{{name}} = nil
-            {% end %}
-          {% end %}
-        end
-        apply_defaults
-        clear_changes_information
       end
 
-      # Serialize from a trusted JSON source
-      def self.from_trusted_json(string_or_io : String | IO) : self
-        {{@type.name.id}}.new(::JSON::PullParser.new(string_or_io), true)
-      end
+      apply_defaults
+      clear_changes_information
+    end
 
-      YAML.mapping(
-        {% for name, opts in PERSIST %}
-          {% if opts[:converter] %}
-            {{name}}: { type: {{opts[:type_signature]}}, setter: false, converter: {{opts[:converter]}} },
-          {% else %}
-            {{name}}: { type: {{opts[:type_signature]}}, setter: false },
-          {% end %}
-        {% end %}
-      )
-
-      # :nodoc:
-      def initialize(%yaml : YAML::ParseContext, %node : ::YAML::Nodes::Node, _dummy : Nil, trusted = false)
-        previous_def(%yaml, %node, nil)
-        if !trusted
-          {% for name, opts in FIELDS %}
-            {% if !opts[:mass_assign] %}
-              @{{name}} = nil
-            {% end %}
-          {% end %}
-        end
-        apply_defaults
-        clear_changes_information
-      end
+    def self.from_json(string_or_io : String | IO, trusted : Bool = false) : self
+      super(string_or_io).tap &.after_initialize(trusted: trusted)
+    end
 
-      # Serialize from a trusted YAML source
-      def self.from_trusted_yaml(string_or_io : String | IO) : self
-        ctx = YAML::ParseContext.new
-        node = begin
-          document = YAML::Nodes.parse(string_or_io)
-
-          # If the document is empty we simulate an empty scalar with
-          # plain style, that parses to Nil
-          document.nodes.first? || begin
-            scalar = YAML::Nodes::Scalar.new("")
-            scalar.style = YAML::ScalarStyle::PLAIN
-            scalar
-          end
-        end
-        {{@type.name.id}}.new(ctx, node, nil, true)
-      end
+    # Serialize from a trusted JSON source
+    def self.from_trusted_json(string_or_io : String | IO) : self
+      self.from_json(string_or_io, trusted: true)
+    end
 
-      def assign_attributes_from_json(json)
-        json = json.read_string(json.read_remaining) if json.responds_to? :read_remaining && json.responds_to? :read_string
-        model = self.class.from_json(json)
-        data = JSON.parse(json).as_h
-        {% for name, opts in FIELDS %}
-          {% if opts[:mass_assign] %}
-            self.{{name}} = model.{{name}} if data.has_key?({{name.stringify}}) && self.{{name}} != model.{{name}}
-          {% end %}
-        {% end %}
+    def self.from_yaml(string_or_io : String | IO, trusted : Bool = false) : self
+      super(string_or_io).tap &.after_initialize(trusted: trusted)
+    end
 
-        self
-      end
+    # Serialize from a trusted YAML source
+    def self.from_trusted_yaml(string_or_io : String | IO) : self
+      self.from_yaml(string_or_io, trusted: true)
+    end
 
-      def assign_attributes_from_trusted_json(json)
-        json = json.read_string(json.read_remaining) if json.responds_to? :read_remaining && json.responds_to? :read_string
-        model = self.class.from_trusted_json(json)
-        data = JSON.parse(json).as_h
-        {% for name, opts in FIELDS %}
+    def assign_attributes_from_json(json)
+      json = json.read_string(json.read_remaining) if json.responds_to? :read_remaining && json.responds_to? :read_string
+      model = self.class.from_json(json)
+      data = JSON.parse(json).as_h
+      {% for name, opts in FIELDS %}
+        {% if opts[:mass_assign] %}
           self.{{name}} = model.{{name}} if data.has_key?({{name.stringify}}) && self.{{name}} != model.{{name}}
         {% end %}
+      {% end %}
 
-        self
-      end
+      self
+    end
 
-      # Uses the YAML parser as JSON is valid YAML
-      def assign_attributes_from_yaml(yaml)
-        yaml = yaml.read_string(yaml.read_remaining) if yaml.responds_to? :read_remaining && yaml.responds_to? :read_string
-        model = self.class.from_yaml(yaml)
-        data = YAML.parse(yaml).as_h
-        {% for name, opts in FIELDS %}
-          {% if opts[:mass_assign] %}
-            self.{{name}} = model.{{name}} if data.has_key?({{name.stringify}}) && self.{{name}} != model.{{name}}
-          {% end %}
-        {% end %}
+    # Assign each field from JSON if field exists in JSON and has changed in model
+    def assign_attributes_from_trusted_json(json)
+      json = json.read_string(json.read_remaining) if json.responds_to? :read_remaining && json.responds_to? :read_string
+      model = self.class.from_trusted_json(json)
+      data = JSON.parse(json).as_h
+      {% for name, opts in FIELDS %}
+        self.{{name}} = model.{{name}} if data.has_key?({{name.stringify}}) && self.{{name}} != model.{{name}}
+      {% end %}
 
-        self
-      end
+      self
+    end
 
-      def assign_attributes_from_trusted_yaml(yaml)
-        yaml = yaml.read_string(yaml.read_remaining) if yaml.responds_to? :read_remaining && yaml.responds_to? :read_string
-        model = self.class.from_trusted_yaml(yaml)
-        data = YAML.parse(yaml).as_h
-        {% for name, opts in FIELDS %}
+    # Uses the YAML parser as JSON is valid YAML
+    def assign_attributes_from_yaml(yaml)
+      yaml = yaml.read_string(yaml.read_remaining) if yaml.responds_to? :read_remaining && yaml.responds_to? :read_string
+      model = self.class.from_yaml(yaml)
+      data = YAML.parse(yaml).as_h
+      {% for name, opts in FIELDS %}
+        {% if opts[:mass_assign] %}
           self.{{name}} = model.{{name}} if data.has_key?({{name.stringify}}) && self.{{name}} != model.{{name}}
         {% end %}
+      {% end %}
 
-        self
-      end
+      self
+    end
 
-    {% end %}
+    def assign_attributes_from_trusted_yaml(yaml)
+      yaml = yaml.read_string(yaml.read_remaining) if yaml.responds_to? :read_remaining && yaml.responds_to? :read_string
+      model = self.class.from_trusted_yaml(yaml)
+      data = YAML.parse(yaml).as_h
+      {% for name, opts in FIELDS %}
+        self.{{name}} = model.{{name}} if data.has_key?({{name.stringify}}) && self.{{name}} != model.{{name}}
+      {% end %}
+
+      self
+    end
   end
 
   macro __nilability_validation__
@@ -496,22 +462,51 @@ abstract class ActiveModel::Model
     {% end %}
   end
 
+  # Declare attributes in real model
   macro attribute(name, converter = nil, mass_assignment = true, persistence = true, **tags, &block)
+    # Declaring correct type of attribute
     {% resolved_type = name.type.resolve %}
     {% if resolved_type.nilable? %}
       {% type_signature = resolved_type %}
     {% else %}
       {% type_signature = "#{resolved_type} | Nil".id %}
     {% end %}
 
+    # Assign instance variable to correct type
+
+    @[JSON::Field(
+      presence: true,
+      {% if !persistence %}
+        ignore: true,
+      {% end %}
+      {% if !converter.nil? %}
+        converter: {{converter}}
+      {% end %}
+    )]
+    @[YAML::Field(
+      presence: true,
+      {% if !persistence %}
+        ignore: true,
+      {% end %}
+      {% if !converter.nil? %}
+        converter: {{converter}}
+      {% end %}
+    )]
     @{{name.var}} : {{type_signature.id}}
 
+    @[JSON::Field(ignore: true)]
+    @[YAML::Field(ignore: true)]
+    getter? {{name.var}}_present : Bool = false
+
     # Attribute default value
     def {{name.var.id}}_default : {{ name.type }}
+      # Check if name.value is not nil
       {% if name.value || name.value == false %}
         {{ name.value }}
+      # Type is not nilable
       {% elsif !resolved_type.nilable? %}
         raise NilAssertionError.new("No default for {{@type}}{{'#'.id}}{{name.var.id}}" )
+      # Type is nilable
       {% else %}
         nil
       {% end %}
@@ -544,7 +539,10 @@ abstract class ActiveModel::Model
         type_signature: type_signature,
       }
     %}
+
     {% HAS_KEYS[0] = true %}
+
+    # Declare default values if name.value is not nil
     {% if name.value || name.value == false %}
       {% DEFAULTS[name.var.id] = name.value %}
     {% end %}