taro 1.0.0 → 1.2.0

data/lib/taro/rails/response_validator.rb

@@ -0,0 +1,109 @@
+Taro::Rails::ResponseValidator = Struct.new(:controller, :declaration, :rendered) do
+  def self.call(*args)
+    new(*args).call
+  end
+
+  def call
+    if declared_return_type < Taro::Types::ScalarType
+      check_scalar
+    elsif declared_return_type < Taro::Types::ListType &&
+          declared_return_type.item_type < Taro::Types::ScalarType
+      check_scalar_array
+    elsif declared_return_type < Taro::Types::EnumType
+      check_enum
+    else
+      check_custom_type
+    end
+  end
+
+  def declared_return_type
+    @declared_return_type ||= begin
+      return_type = declaration.returns[controller.status] ||
+                    fail_with('No return type declared for this status.')
+      nesting ? return_type.fields.fetch(nesting).type : return_type
+    end
+  end
+
+  def fail_with(message)
+    raise Taro::ResponseError, <<~MSG
+      Response validation error for
+      #{controller.class}##{controller.action_name}, code #{controller.status}":
+      #{message}
+    MSG
+  end
+
+  # support `returns :some_nesting, type: 'SomeType'` (ad-hoc return type)
+  def nesting
+    @nesting ||= declaration.return_nestings[controller.status]
+  end
+
+  def denest_rendered
+    assert_rendered_is_a_hash
+
+    if rendered.key?(nesting)
+      rendered[nesting]
+    elsif rendered.key?(nesting.to_s)
+      rendered[nesting.to_s]
+    else
+      fail_with_nesting_error
+    end
+  end
+
+  def assert_rendered_is_a_hash
+    rendered.is_a?(Hash) || fail_with("Expected Hash, got #{rendered.class}.")
+  end
+
+  def fail_with_nesting_error
+    fail_with "Expected key :#{nesting}, got: #{rendered.keys}."
+  end
+
+  # For scalar and enum types, we want to support e.g. `render json: 42`,
+  # and not require using the type as in `BeautifulNumbersEnum.render(42)`.
+  def check_scalar(type = declared_return_type, value = subject)
+    case type.openapi_type
+    when :integer, :number then value.is_a?(Numeric)
+    when :string           then value.is_a?(String) || value.is_a?(Symbol)
+    when :boolean          then [true, false].include?(value)
+    end || fail_with("Expected a #{type.openapi_type}, got: #{value.class}.")
+  end
+
+  def subject
+    @subject ||= nesting ? denest_rendered : rendered
+  end
+
+  def check_scalar_array
+    subject.is_a?(Array) || fail_with('Expected an Array.')
+    subject.empty? || check_scalar(declared_return_type.item_type, subject.first)
+  end
+
+  def check_enum
+    # coercion checks non-emptyness + enum match
+    declared_return_type.new(subject).coerce_response
+  rescue Taro::Error => e
+    fail_with(e.message)
+  end
+
+  # For complex/object types, we ensure conformance by checking whether
+  # the type was used for rendering. This has performance benefits compared
+  # to going over the structure a second time.
+  def check_custom_type
+    # Ignore types without a specified structure.
+    return if declared_return_type <= Taro::Types::ObjectTypes::FreeFormType
+    return if declared_return_type <= Taro::Types::ObjectTypes::NoContentType
+
+    strict_check_custom_type
+  end
+
+  def strict_check_custom_type
+    used_type, rendered_object_id = declared_return_type.last_render
+    used_type&.<=(declared_return_type) || fail_with(<<~MSG)
+      Expected to use #{declared_return_type}.render, but the last type rendered
+      was: #{used_type || 'no type'}.
+    MSG
+
+    rendered_object_id == subject.__id__ || fail_with(<<~MSG)
+      #{declared_return_type}.render was called, but the result
+      of this call was not used in the response.
+    MSG
+  end
+end

data/lib/taro/rails/tasks/export.rake

@@ -10,6 +10,10 @@ task 'taro:export' => :environment do
     version: Taro.config.api_version,
   )
 
-  data = export.result.send("to_#{Taro.config.export_format}")
+  data = export.send("to_#{Taro.config.export_format}")
+
+  FileUtils.mkdir_p(File.dirname(Taro.config.export_path))
   File.write(Taro.config.export_path, data)
+
+  puts "Exported #{Taro.config.api_name} to #{Taro.config.export_path}"
 end

data/lib/taro/rails.rb

@@ -12,7 +12,6 @@ module Taro::Rails
     buffered_declarations.clear
     declarations_map.clear
     RouteFinder.clear_cache
-    Taro::Types::BaseType.rendering = nil
-    Taro::Types::BaseType.used_in_response = nil
+    Taro::Types::BaseType.last_render = nil
   end
 end

data/lib/taro/types/base_type.rb

@@ -9,6 +9,8 @@
 Taro::Types::BaseType = Data.define(:object) do
   require_relative "shared"
   extend Taro::Types::Shared::AdditionalProperties
+  extend Taro::Types::Shared::Deprecation
+  extend Taro::Types::Shared::DerivedTypes
   extend Taro::Types::Shared::Description
   extend Taro::Types::Shared::OpenAPIName
   extend Taro::Types::Shared::OpenAPIType

data/lib/taro/types/coercion.rb

@@ -1,42 +1,52 @@
 module Taro::Types::Coercion
-  KEYS = %i[type array_of page_of].freeze
-
   class << self
     def call(arg)
       validate_hash(arg)
       from_hash(arg)
     end
 
+    # Coercion keys can be expanded by the DerivedTypes module.
+    def keys
+      @keys ||= %i[type]
+    end
+
+    def derived_suffix
+      '_of'
+    end
+
     private
 
     def validate_hash(arg)
       arg.is_a?(Hash) || raise(Taro::ArgumentError, <<~MSG)
-        Type coercion argument must be a Hash, got: #{arg.inspect} (#{arg.class})
+        Type coercion argument must be a Hash, got: #{arg.class}
       MSG
 
-      types = arg.slice(*KEYS)
+      types = arg.slice(*keys)
       types.size == 1 || raise(Taro::ArgumentError, <<~MSG)
-        Exactly one of type, array_of, or page_of must be given, got: #{types}
+        Exactly one of #{keys.join(', ')} must be given, got: #{types}
       MSG
     end
 
     def from_hash(hash)
-      if hash[:type]
-        from_string(hash[:type])
-      elsif (inner_type = hash[:array_of])
-        from_string(inner_type).array
-      elsif (inner_type = hash[:page_of])
-        from_string(inner_type).page
-      else
-        raise NotImplementedError, 'Unsupported type coercion'
+      keys.each do |key|
+        next unless (value = hash[key])
+
+        # e.g. `returns type: 'MyType'` -> MyType
+        return from_string(value) if key == :type
+
+        # DerivedTypes
+        # e.g. `returns array_of: 'MyType'` -> MyType.array
+        return from_string(value).send(key.to_s.chomp(derived_suffix))
       end
+
+      raise NotImplementedError, "Unsupported type coercion #{hash}"
     end
 
     def from_string(arg)
       shortcuts[arg] || from_class(Object.const_get(arg.to_s))
     rescue NameError
       raise Taro::ArgumentError, <<~MSG
-        Unsupported type: #{arg}. It should be a type-class name
+        No such type: #{arg}. It should be a type-class name
         or one of #{shortcuts.keys.map(&:inspect).join(', ')}.
       MSG
     end
@@ -56,15 +66,16 @@ module Taro::Types::Coercion
       @shortcuts ||= {
         # rubocop:disable Layout/HashAlignment - buggy cop
         'Boolean'   => Taro::Types::Scalar::BooleanType,
+        'Date'      => Taro::Types::Scalar::ISO8601DateType,
+        'DateTime'  => Taro::Types::Scalar::ISO8601DateTimeType,
         'Float'     => Taro::Types::Scalar::FloatType,
         'FreeForm'  => Taro::Types::ObjectTypes::FreeFormType,
         'Integer'   => Taro::Types::Scalar::IntegerType,
+        'NoContent' => Taro::Types::ObjectTypes::NoContentType,
         'String'    => Taro::Types::Scalar::StringType,
+        'Time'      => Taro::Types::Scalar::ISO8601DateTimeType,
         'Timestamp' => Taro::Types::Scalar::TimestampType,
         'UUID'      => Taro::Types::Scalar::UUIDv4Type,
-        'Date'      => Taro::Types::Scalar::ISO8601DateType,
-        'Time'      => Taro::Types::Scalar::ISO8601DateTimeType,
-        'DateTime'  => Taro::Types::Scalar::ISO8601DateTimeType,
         # rubocop:enable Layout/HashAlignment - buggy cop
       }.freeze
     end

data/lib/taro/types/enum_type.rb

@@ -18,7 +18,7 @@ class Taro::Types::EnumType < Taro::Types::BaseType
     if self.class.values.include?(value)
       value
     else
-      input_error("must be one of #{self.class.values}")
+      input_error("must be #{self.class.values.map(&:inspect).join(' or ')}")
     end
   end
 
@@ -28,7 +28,7 @@ class Taro::Types::EnumType < Taro::Types::BaseType
     if self.class.values.include?(value)
       value
     else
-      response_error("must be one of #{self.class.values}")
+      response_error("must be #{self.class.values.map(&:inspect).join(' or ')}")
     end
   end
 

data/lib/taro/types/field.rb

@@ -1,11 +1,11 @@
 require_relative 'field_validation'
 
-Taro::Types::Field = Data.define(:name, :type, :null, :method, :default, :enum, :defined_at, :desc) do
+Taro::Types::Field = Data.define(:name, :type, :null, :method, :default, :enum, :defined_at, :desc, :deprecated) do
   include Taro::Types::FieldValidation
 
-  def initialize(name:, type:, null:, method: name, default: :none, enum: nil, defined_at: nil, desc: nil)
+  def initialize(name:, type:, null:, method: name, default: :none, enum: nil, defined_at: nil, desc: nil, deprecated: nil)
     enum = coerce_to_enum(enum)
-    super(name:, type:, null:, method:, default:, enum:, defined_at:, desc:)
+    super(name:, type:, null:, method:, default:, enum:, defined_at:, desc:, deprecated:)
   end
 
   def value_for_input(object)
@@ -40,14 +40,15 @@ Taro::Types::Field = Data.define(:name, :type, :null, :method, :default, :enum,
   end
 
   def retrieve_response_value(object, context, object_is_hash)
-    if object_is_hash
-      retrieve_hash_value(object)
-    elsif context&.resolve?(method)
+    if context&.resolve?(method)
       context.public_send(method)
+    elsif object_is_hash
+      retrieve_hash_value(object)
     elsif object.respond_to?(method, true)
       object.public_send(method)
     else
-      raise_response_coercion_error(object)
+      # Note that the ObjectCoercion module rescues this and adds context.
+      raise Taro::ResponseError, "No such method or resolver `:#{method}`."
     end
   end
 
@@ -65,14 +66,5 @@ Taro::Types::Field = Data.define(:name, :type, :null, :method, :default, :enum,
 
     type_obj = type.new(value)
     from_input ? type_obj.coerce_input : type_obj.coerce_response
-  rescue Taro::Error => e
-    raise e.class, "#{e.message}, after using method/key `:#{method}` to resolve field `#{name}`"
-  end
-
-  def raise_response_coercion_error(object)
-    raise Taro::ResponseError, <<~MSG
-      Failed to coerce value #{object.inspect} for field `#{name}` using method/key `:#{method}`.
-      It is not a valid #{type} value.
-    MSG
   end
 end

data/lib/taro/types/field_validation.rb

@@ -18,7 +18,7 @@ module Taro::Types::FieldValidation
   end
 
   def validate_enum_inclusion(value, for_input)
-    return if enum.nil? || enum.include?(value)
+    return if enum.nil? || null && value.nil? || enum.include?(value)
 
     raise for_input ? Taro::InputError : Taro::ResponseError, <<~MSG
       Field #{name} has an invalid value #{value.inspect} (expected one of #{enum.inspect})

data/lib/taro/types/list_type.rb

@@ -2,7 +2,6 @@
 # Unlike other types, this one should not be manually inherited from,
 # but is used indirectly via `array_of: SomeType`.
 class Taro::Types::ListType < Taro::Types::BaseType
-  extend Taro::Types::Shared::DerivableType
   extend Taro::Types::Shared::ItemType
 
   self.openapi_type = :array
@@ -20,11 +19,10 @@ class Taro::Types::ListType < Taro::Types::BaseType
     item_type = self.class.item_type
     object.map { |el| item_type.new(el).coerce_response }
   end
-end
 
-# add shortcut to other types
-class Taro::Types::BaseType
-  def self.array
-    Taro::Types::ListType.for(self)
+  def self.default_openapi_name
+    "#{item_type.openapi_name}_List"
   end
+
+  define_derived_type :array, 'Taro::Types::ListType'
 end

data/lib/taro/types/object_types/free_form_type.rb

@@ -1,6 +1,7 @@
 class Taro::Types::ObjectTypes::FreeFormType < Taro::Types::ObjectType
   self.desc = 'An arbitrary, unvalidated Hash or JSON object. Use with care.'
   self.additional_properties = true
+  self.openapi_name = 'FreeForm'
 
   def coerce_input
     object.is_a?(Hash) && object || input_error('must be a Hash')

data/lib/taro/types/object_types/no_content_type.rb

@@ -1,5 +1,6 @@
 class Taro::Types::ObjectTypes::NoContentType < Taro::Types::ObjectType
   self.desc = 'An empty response'
+  self.openapi_name = 'NoContent'
 
   # render takes no arguments in this case
   def self.render

data/lib/taro/types/object_types/page_info_type.rb

@@ -1,4 +1,6 @@
 class Taro::Types::ObjectTypes::PageInfoType < Taro::Types::ObjectType
+  self.openapi_name = 'PageInfo'
+
   field :has_previous_page, type: 'Boolean', null: false, desc: 'Whether there is a previous page of results'
   field :has_next_page, type: 'Boolean', null: false, desc: 'Whether there is another page of results'
   field :start_cursor, type: 'String', null: true, desc: 'The first cursor in the current page of results (null if zero results)'

data/lib/taro/types/object_types/page_type.rb

@@ -4,42 +4,32 @@
 #
 # The gem rails_cursor_pagination must be installed to use this.
 #
-class Taro::Types::ObjectTypes::PageType < Taro::Types::BaseType
-  extend Taro::Types::Shared::DerivableType
+class Taro::Types::ObjectTypes::PageType < Taro::Types::ObjectType
   extend Taro::Types::Shared::ItemType
 
+  def self.derive_from(from_type)
+    super
+    field(:page, array_of: from_type.name, null: false)
+    field(:page_info, type: 'Taro::Types::ObjectTypes::PageInfoType', null: false)
+  end
+
   def coerce_input
     input_error 'PageTypes cannot be used as input types'
   end
 
-  def coerce_response(after:, limit: 20, order_by: nil, order: nil)
-    list = RailsCursorPagination::Paginator.new(
-      object, limit:, order_by:, order:, after:
+  def self.render(relation, after:, limit: 20, order_by: nil, order: nil)
+    result = RailsCursorPagination::Paginator.new(
+      relation, limit:, order_by:, order:, after:
     ).fetch
-    coerce_paginated_list(list)
-  end
 
-  def coerce_paginated_list(list)
-    item_type = self.class.item_type
-    items = list[:page].map do |item|
-      item_type.new(item[:data]).coerce_response
-    end
+    result[:page].map! { |el| el.fetch(:data) }
 
-    {
-      self.class.items_key => items,
-      page_info: Taro::Types::ObjectTypes::PageInfoType.new(list[:page_info]).coerce_response,
-    }
+    super(result)
   end
 
-  # support overrides, e.g. based on item_type
-  def self.items_key
-    :page
+  def self.default_openapi_name
+    "#{item_type.openapi_name}_Page"
   end
-end
 
-# add shortcut to other types
-class Taro::Types::BaseType
-  def self.page
-    Taro::Types::ObjectTypes::PageType.for(self)
-  end
+  define_derived_type :page, 'Taro::Types::ObjectTypes::PageType'
 end

data/lib/taro/types/scalar/iso8601_date_type.rb

@@ -1,5 +1,6 @@
 class Taro::Types::Scalar::ISO8601DateType < Taro::Types::ScalarType
   self.desc = 'Represents a time as Date in ISO8601 format.'
+  self.openapi_name = 'ISO8601Date'
   self.openapi_type = :string
 
   PATTERN = /\A\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])\z/

data/lib/taro/types/scalar/iso8601_datetime_type.rb

@@ -1,5 +1,6 @@
 class Taro::Types::Scalar::ISO8601DateTimeType < Taro::Types::ScalarType
   self.desc = 'Represents a time as DateTime in ISO8601 format.'
+  self.openapi_name = 'ISO8601DateTime'
   self.openapi_type = :string
 
   PATTERN = /\A\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T([01]\d|2[0-3]):[0-5]\d:[0-5]\d(Z|[+-](0[0-9]|1[0-4]):[0-5]\d)\z/

data/lib/taro/types/scalar/timestamp_type.rb

@@ -1,5 +1,6 @@
 class Taro::Types::Scalar::TimestampType < Taro::Types::ScalarType
   self.desc = 'Represents a time as Time on the server side and UNIX timestamp (integer) on the client side.'
+  self.openapi_name = 'Timestamp'
   self.openapi_type = :integer
 
   def coerce_input

data/lib/taro/types/scalar/uuid_v4_type.rb

@@ -1,5 +1,6 @@
 class Taro::Types::Scalar::UUIDv4Type < Taro::Types::ScalarType
   self.desc = "A UUID v4 string"
+  self.openapi_name = 'UUIDv4'
   self.openapi_type = :string
 
   PATTERN = /\A\h{8}-?(?:\h{4}-?){3}\h{12}\z/

data/lib/taro/types/shared/deprecation.rb

@@ -0,0 +1,3 @@
+module Taro::Types::Shared::Deprecation
+  attr_accessor :deprecated
+end

data/lib/taro/types/shared/derived_types.rb

@@ -0,0 +1,27 @@
+module Taro::Types::Shared::DerivedTypes
+  # Adds `name` as a method to all type classes and adds
+  # `name`_of as a supported key to the Coercion module.
+  # When `name` is called on a type class T, it returns a new subclass
+  # S inheriting from `type` and passes T to S::derive_from.
+  def define_derived_type(name, type)
+    root = Taro::Types::BaseType
+    raise ArgumentError, "#{name} is already in use" if root.respond_to?(name)
+
+    ckey = :"#{name}#{Taro::Types::Coercion.derived_suffix}"
+    ckeys = Taro::Types::Coercion.keys
+    raise ArgumentError, "#{ckey} is already in use" if ckeys.include?(ckey)
+
+    root.define_singleton_method(name) do
+      derived_types[type] ||= begin
+        type_class = Taro::Types::Coercion.call(type:)
+        Class.new(type_class).tap { |t| t.derive_from(self) }
+      end
+    end
+
+    ckeys << ckey
+  end
+
+  def derived_types
+    @derived_types ||= {}
+  end
+end

data/lib/taro/types/shared/errors.rb

@@ -8,6 +8,8 @@ module Taro::Types::Shared::Errors
   end
 
   def coerce_error_message(msg)
-    "#{object.inspect} (#{object.class}) is not valid as #{self.class}: #{msg}"
+    type_desc = (self.class.name || self.class.superclass.name)
+                .sub(/^Taro::Types::.*?([^:]+)Type$/, '\1')
+    "#{object.class} is not valid as #{type_desc}: #{msg}"
   end
 end

data/lib/taro/types/shared/fields.rb

@@ -2,7 +2,7 @@
 module Taro::Types::Shared::Fields
   # Field types are set using class name Strings. The respective type classes
   # are evaluated lazily to allow for circular or recursive type references,
-  # and to avoid unnecessary eager loading of all types in dev/test envs.
+  # and to avoid unnecessary autoloading of all types in dev/test envs.
   def field(name, **kwargs)
     defined_at = kwargs[:defined_at] || caller_locations(1..1)[0]
     validate_name(name, defined_at:)
@@ -27,11 +27,12 @@ module Taro::Types::Shared::Fields
     [true, false].include?(kwargs[:null]) ||
       raise(Taro::ArgumentError, "null has to be specified as true or false for field #{name} at #{defined_at}")
 
-    (type_keys = (kwargs.keys & Taro::Types::Coercion::KEYS)).size == 1 ||
-      raise(Taro::ArgumentError, "exactly one of type, array_of, or page_of must be given for field #{name} at #{defined_at}")
+    c_keys = Taro::Types::Coercion.keys
+    (type_keys = (kwargs.keys & c_keys)).size == 1 ||
+      raise(Taro::ArgumentError, "exactly one of #{c_keys.join(', ')} must be given for field #{name} at #{defined_at}")
 
     kwargs[type_keys.first].class == String ||
-      raise(Taro::ArgumentError, "#{type_key} must be a String for field #{name} at #{defined_at}")
+      raise(Taro::ArgumentError, "#{type_keys.first} must be a String for field #{name} at #{defined_at}")
   end
 
   def validate_no_override(name, defined_at:)
@@ -46,7 +47,7 @@ module Taro::Types::Shared::Fields
   def evaluate_field_defs
     field_defs.transform_values do |field_def|
       type = Taro::Types::Coercion.call(field_def)
-      Taro::Types::Field.new(**field_def.except(*Taro::Types::Coercion::KEYS), type:)
+      Taro::Types::Field.new(**field_def.except(*Taro::Types::Coercion.keys), type:)
     end
   end
 

data/lib/taro/types/shared/item_type.rb

@@ -6,6 +6,7 @@ module Taro::Types::Shared::ItemType
     item_type.nil? || new_type == item_type || raise_mixed_types(new_type)
     @item_type = new_type
   end
+  alias_method :derive_from, :item_type=
 
   def raise_mixed_types(new_type)
     raise Taro::ArgumentError, <<~MSG

data/lib/taro/types/shared/object_coercion.rb

@@ -3,6 +3,8 @@ module Taro::Types::Shared::ObjectCoercion
   def coerce_input
     self.class.fields.transform_values do |field|
       field.value_for_input(object)
+    rescue Taro::Error => e
+      raise_enriched_coercion_error(e, field)
     end
   end
 
@@ -11,6 +13,17 @@ module Taro::Types::Shared::ObjectCoercion
     object_is_hash = object.is_a?(Hash)
     self.class.fields.transform_values do |field|
       field.value_for_response(object, context: self, object_is_hash:)
+    rescue Taro::Error => e
+      raise_enriched_coercion_error(e, field)
     end
   end
+
+  def raise_enriched_coercion_error(error, field)
+    # The indentation is on purpose. These errors can be recursively rescued
+    # and re-raised by a tree of object types, which should be made apparent.
+    raise error.class, <<~MSG
+      Failed to read #{self.class.name} field `#{field.name}` from #{object.class}:
+      #{error.message.lines.map { |line| "  #{line}" }.join}
+    MSG
+  end
 end

data/lib/taro/types/shared/openapi_name.rb

@@ -5,13 +5,19 @@ module Taro::Types::Shared::OpenAPIName
     @openapi_name ||= default_openapi_name
   end
 
+  def openapi_name?
+    !!openapi_name
+  rescue Taro::Error
+    false
+  end
+
   def openapi_name=(arg)
     arg.nil? || arg.is_a?(String) ||
       raise(Taro::ArgumentError, 'openapi_name must be a String')
     @openapi_name = arg
   end
 
-  def default_openapi_name # rubocop:disable Metrics
+  def default_openapi_name
     if self < Taro::Types::EnumType ||
        self < Taro::Types::InputType ||
        self < Taro::Types::ObjectType
@@ -19,12 +25,8 @@ module Taro::Types::Shared::OpenAPIName
         raise(Taro::Error, 'openapi_name must be set for anonymous type classes')
     elsif self < Taro::Types::ScalarType
       openapi_type
-    elsif self < Taro::Types::ListType
-      "#{item_type.openapi_name}_List"
-    elsif self < Taro::Types::ObjectTypes::PageType
-      "#{item_type.openapi_name}_Page"
     else
-      raise NotImplementedError, 'no default_openapi_name for this type'
+      raise Taro::Error, 'no default_openapi_name implemented for this type'
     end
   end
 end

data/lib/taro/types/shared/rendering.rb

@@ -1,36 +1,22 @@
-# The `::render` method is intended for use in controllers.
-# Special types (e.g. PageType) may accept kwargs for `#coerce_response`.
 module Taro::Types::Shared::Rendering
-  def render(object, opts = {})
-    if (prev = rendering)
-      raise Taro::RuntimeError, <<~MSG
-        Type.render should only be called once per request.
-        (First called on #{prev}, then on #{self}.)
-      MSG
-    end
-
-    result = new(object).coerce_response(**opts)
-
-    # Only mark this as the used type if coercion worked so that
-    # rescue_from can be used to render another type.
-    self.rendering = self
-
+  # The `::render` method is intended for use in controllers.
+  # Overrides of this method must call super.
+  def render(object)
+    result = new(object).coerce_response
+    self.last_render = [self, result.__id__]
     result
   end
 
-  def rendering=(value)
-    ActiveSupport::IsolatedExecutionState[:taro_type_rendering] = value
-  end
-
-  def rendering
-    ActiveSupport::IsolatedExecutionState[:taro_type_rendering]
+  def last_render=(info)
+    ActiveSupport::IsolatedExecutionState[:taro_last_render] = info
   end
 
-  def used_in_response=(value)
-    ActiveSupport::IsolatedExecutionState[:taro_type_used_in_response] = value
+  def last_render
+    ActiveSupport::IsolatedExecutionState[:taro_last_render]
   end
 
+  # get the last used type for assertions in tests/specs
   def used_in_response
-    ActiveSupport::IsolatedExecutionState[:taro_type_used_in_response]
+    last_render.to_a.first
   end
 end

data/lib/taro/version.rb

@@ -1,4 +1,4 @@
 # :nocov:
 module Taro
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

data/tasks/benchmark.rake

@@ -13,7 +13,7 @@ task :benchmark do
     field :version, type: 'Float', null: false
   end
 
-  type = Taro::Types::ListType.for(item_type)
+  type = item_type.array
 
   # 143.889k (± 2.7%) i/s -    723.816k in   5.034247s
   Benchmark.ips do |x|