Update Introspection (#17)

* dont redo the work when passing a Generator object for arrayed subclass

* to_h on objects that have generator as key was failing -- recursively go through object instead

* pluck introspection specs to own file

* bump version

* allow introspection of class schema; pull out instrospection to own file

* version

* better validation for introspection

Author: matt-taylor

.ruby-version

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    json_schematize (0.10.0)
+    json_schematize (0.11.0)
       class_composer (>= 1.0)
 
 GEM

Gemfile.lock

@@ -5,7 +5,7 @@
 
 class JsonSchematize::Field
 
-  attr_reader :name, :types, :dig, :dig_type, :symbol, :validator, :empty_value
+  attr_reader :name, :types, :type, :dig, :dig_type, :symbol, :validator, :empty_value
   attr_reader :acceptable_types, :required, :converter, :array_of_types
 
   EXPECTED_DIG_TYPE = [DIG_SYMBOL = :symbol, DEFAULT_DIG = DIG_NONE =:none, DIG_STRING = :string]
@@ -89,7 +89,11 @@ def value_from_field(params)
   private
 
   def validate_acceptable_types(val:)
-    (all_allowed_types + @acceptable_types).include?(val.class)
+    types = (all_allowed_types + @acceptable_types)
+    return true if types.include?(val.class)
+
+    # Allow inheritance here as well -- this only works when a custom converter is defined
+    Class === val ? types.any? { _1 > val } : false
   end
 
   def all_allowed_types
@@ -108,8 +112,14 @@ def iterate_array_of_types(value:)
       raise JsonSchematize::InvalidFieldByArrayOfTypes, ":#{name} expected to be an array based on :array_of_types flag. Given #{value.class}"
     end
 
-    value.map do |val|
-      raw_converter_call(value: val)
+    if value.all? { JsonSchematize::Generator === _1 }
+      # We have already done the work to convert it into a Schematizable object
+      # Return the array and allow the remaining validations to take place
+      value
+    else
+      value.map do |val|
+        raw_converter_call(value: val)
+      end
     end
   end
 

lib/json_schematize/field.rb

@@ -2,13 +2,15 @@
 
 require "json_schematize/cache"
 require "json_schematize/field"
-require "json_schematize/introspect"
+require "json_schematize/introspect_instance_methods"
+require "json_schematize/introspect_class_methods"
 
 class JsonSchematize::Generator
   EMPTY_VALIDATOR = ->(_transformed_value, _raw_value) { true }
   PROTECTED_METHODS = [:assign_values!, :convenience_methods, :validate_required!, :validate_optional!, :validate_value]
 
-  include JsonSchematize::Introspect
+  include JsonSchematize::Introspect::InstanceMethods
+  extend JsonSchematize::Introspect::ClassMethods
 
   def self.add_field(name:, type: nil, types: nil, dig_type: nil, dig: nil, validator: nil, required: nil, converter: nil, array_of_types: nil, empty_value: nil, hash_of_types: nil, hash_of_types_key: "name")
     require "json_schematize/empty_value"

lib/json_schematize/generator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module JsonSchematize::Introspect
+  module ClassMethods
+    def introspect(deep: false, prepend_dig: [], introspection: {})
+      fields.each do |field|
+        naming = (prepend_dig + field.dig).compact
+        type_metadata = __field_type__(field)
+        introspection[naming.join(".")] = {
+          required: field.required,
+          allowed: type_metadata[:humanize],
+        }
+
+        if deep && type_metadata[:deep_introspection]
+          prepended_naming = if field.array_of_types
+            naming.dup.tap { _1[-1] = "#{_1[-1]}[x]"}
+          else
+            naming.dup
+          end
+          type_metadata[:types][0].introspect(deep:, prepend_dig: prepended_naming, introspection: introspection)
+        end
+      end
+
+      introspection
+    end
+
+    def __field_type__(field)
+      types = Array(field.type || field.types)
+      deep_introspection = false
+      type_string = if types.length == 0
+        "Anything"
+      elsif types.length == 1
+        type = types.first
+        if JsonSchematize::Generator > type
+          deep_introspection = true
+          if field.array_of_types
+            "Array of #{type}"
+          else
+            type
+          end
+        else
+          type
+        end
+      else
+        "One of [#{types}]"
+      end
+
+      {
+        humanize: type_string,
+        types:,
+        deep_introspection:,
+      }
+    end
+  end
+end

lib/json_schematize/introspect.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module JsonSchematize::Introspect
+  module InstanceMethods
+    def to_h
+      self.class.fields.map do |field|
+        value = method(:"#{field.name}").()
+        if field.array_of_types
+          [field.name, value.map(&:to_h)]
+        elsif value.class == Class
+          [field.name, value.to_s]
+        elsif JsonSchematize::Generator > value.class
+          [field.name, value.to_h]
+        else
+          [field.name, value]
+        end
+      end.to_h
+    end
+    alias :to_hash :to_h
+
+    def deep_inspect(with_raw_params: false, with_field: false)
+      self.class.fields.map do |field|
+        value = {
+          required: field.required,
+          acceptable_types: field.acceptable_types,
+          value: instance_variable_get(:"@#{field.name}"),
+        }
+        value[:field] = field if with_field
+        value[:raw_params] = @__raw_params if with_raw_params
+        [field.name, value]
+      end.to_h
+    end
+
+    def inspect
+      stringify = to_h.map { |k, v| "#{k}:#{v}" }.join(", ")
+      "#<#{self.class} - required fields: #{self.class.required_fields.map(&:name)}; #{stringify}>"
+    end
+  end
+end

lib/json_schematize/introspect_class_methods.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JsonSchematize
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

lib/json_schematize/introspect_instance_methods.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 RSpec.describe JsonSchematize::Generator do
-
   describe ".add_field" do
     subject(:add_field) { klass.add_field(**field_params) }
 
@@ -132,99 +131,6 @@ class KlassInit < described_class
     end
   end
 
-  describe "introspection" do
-    let(:instance) { klass.new(**params) }
-
-    let(:params) do
-      {
-        id: 6457,
-        count: 9145,
-        style: :symbol,
-        something: "danger",
-        danger: :count,
-        zone: :zone,
-      }
-    end
-
-    describe "#to_h" do
-      subject(:to_h) { instance.to_h }
-
-      let(:klass) do
-        class IntrospectKlassToH < described_class
-          add_field name: :id, type: Integer
-          add_field name: :count, type: Integer
-          add_field name: :style, type: Symbol
-          add_field name: :something, type: String
-          add_field name: :danger, type: Symbol
-          add_field name: :zone, type: Symbol
-        end
-        IntrospectKlassToH
-      end
-      it { is_expected.to eq(params) }
-    end
-
-    describe "#deep_inspect" do
-      subject(:deep_inspect) { instance.deep_inspect(with_raw_params: with_raw_params, with_field: with_field) }
-
-      let(:klass) do
-        class IntrospectKlassDeepInspect < described_class
-          add_field name: :id, type: Integer
-          add_field name: :count, type: Integer
-          add_field name: :style, type: Symbol
-          add_field name: :something, type: String
-          add_field name: :danger, type: Symbol
-          add_field name: :zone, type: Symbol
-        end
-        IntrospectKlassDeepInspect
-      end
-      let(:with_raw_params) { false }
-      let(:with_field) { false }
-      let(:enumerate_expected) do
-        klass.fields.map do |field|
-          value = {
-            required: field.required,
-            acceptable_types: field.acceptable_types,
-            value: params[field.name],
-          }
-          value[:field] = field if with_field
-          value[:raw_params] = params if with_raw_params
-          [field.name, value]
-        end.to_h
-      end
-
-      it { is_expected.to eq(enumerate_expected) }
-
-      context 'when with_raw_params' do
-        let(:with_raw_params) { true }
-        it { is_expected.to eq(enumerate_expected) }
-      end
-
-      context 'when with_field' do
-        let(:with_field) { true }
-
-        it { is_expected.to eq(enumerate_expected) }
-      end
-    end
-
-    describe "#inspect" do
-      subject(:inspect) { instance.inspect }
-
-      let(:klass) do
-        class IntrospectKlassInspect < described_class
-          add_field name: :id, type: Integer
-          add_field name: :count, type: Integer
-          add_field name: :style, type: Symbol
-          add_field name: :something, type: String
-          add_field name: :danger, type: Symbol
-          add_field name: :zone, type: Symbol
-        end
-        IntrospectKlassInspect
-      end
-      let(:expected) { "#<#{klass} - required fields: #{params.keys}; #{instance.to_h.map { |k, v| "#{k}:#{v}" }.join(", ")}>" }
-      it { is_expected.to eq(expected) }
-    end
-  end
-
   context "when modifying values" do
     let(:instance) { klass.new(raise_on_error: raise_on_error, **params) }
     let(:klass) do