ohauthcat 0.0.2

data/lib/ohauthcat/model.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module OhAuthCat
+  # Base of every generated model. A model wraps its JSON Hash, so unknown fields are kept and
+  # #to_h is always available as an escape hatch. Typed readers and writers use that Hash.
+  class Model
+    REGISTRY = {}
+
+    class << self
+      attr_reader :model_name, :fields, :required_fields
+
+      def model(name, required: [])
+        @model_name = name
+        @fields = {}
+        @required_fields = required.freeze
+        REGISTRY[name] = self
+      end
+
+      def field(member, json_name, desc)
+        @fields[json_name] = desc
+        define_method(member) { Model.decode(@json[json_name], desc) }
+        define_method(:"#{member}=") { |value| @json[json_name] = Model.encode(value) }
+      end
+
+      # Validates decoded JSON and wraps it.
+      def from_json(value)
+        Model.validate(value, "M#{model_name}", model_name, present: true)
+        new(value)
+      end
+
+      def wrap(hash)
+        new(hash)
+      end
+    end
+
+    def initialize(json = {})
+      @json = json.transform_keys(&:to_s)
+    end
+
+    # The underlying JSON Hash: every field, including ones this SDK version does not know.
+    def to_h
+      @json
+    end
+
+    def [](key)
+      @json[key.to_s]
+    end
+
+    def to_json(*args)
+      @json.to_json(*args)
+    end
+
+    def ==(other)
+      other.is_a?(Model) && other.class == self.class && other.to_h == @json
+    end
+
+    def inspect
+      "#<#{self.class.model_name} #{@json.keys.join(", ")}>"
+    end
+
+    def self.invalid(path)
+      ::OhAuthCat::Error.new("The response does not match the API schema at #{path}", code: "response_invalid")
+    end
+
+    def self.validate(value, desc, path, present: true)
+      nullable = desc.start_with?("?")
+      d = nullable ? desc[1..] : desc
+      if value.nil?
+        return if nullable || !present
+
+        raise invalid(path)
+      end
+      case d[0]
+      when "s" then raise invalid(path) unless value.is_a?(String)
+      when "i" then raise invalid(path) unless value.is_a?(Integer)
+      when "n" then raise invalid(path) unless value.is_a?(Numeric)
+      when "b" then raise invalid(path) unless [true, false].include?(value)
+      when "j" then nil
+      when "L"
+        raise invalid(path) unless value.is_a?(Array)
+
+        value.each_with_index { |item, i| validate(item, d[1..], "#{path}[#{i}]") }
+      when "D"
+        raise invalid(path) unless value.is_a?(Hash)
+
+        value.each { |k, v| validate(v, d[1..], "#{path}.#{k}") }
+      when "M"
+        klass = REGISTRY[d[1..]]
+        raise invalid(path) unless klass && value.is_a?(Hash)
+
+        klass.required_fields.each { |f| raise invalid("#{path}.#{f}") unless value.key?(f) }
+        klass.fields.each do |name, field_desc|
+          next unless value.key?(name)
+          # Optional fields may be null even when the schema does not say so.
+          next if value[name].nil? && !klass.required_fields.include?(name)
+
+          validate(value[name], field_desc, "#{path}.#{name}")
+        end
+      else
+        raise invalid(path)
+      end
+    end
+
+    def self.decode(value, desc)
+      return value if value.nil?
+
+      d = desc.delete_prefix("?")
+      case d[0]
+      when "n" then value.is_a?(Numeric) ? value.to_f : value
+      when "L" then value.is_a?(Array) ? value.map { |item| decode(item, d[1..]) } : value
+      when "D" then value.is_a?(Hash) ? value.transform_values { |item| decode(item, d[1..]) } : value
+      when "M"
+        klass = REGISTRY[d[1..]]
+        klass && value.is_a?(Hash) ? klass.wrap(value) : value
+      else value
+      end
+    end
+
+    # Converts typed values (models, arrays, hashes) back into plain JSON values.
+    def self.encode(value)
+      case value
+      when Model then value.to_h
+      when Hash then value.to_h { |k, v| [k.to_s, encode(v)] }
+      when Array then value.map { |item| encode(item) }
+      else value
+      end
+    end
+  end
+end