strong_json 0.9.0 → 1.0.0

data/lib/strong_json/type.rb

@@ -1,7 +1,5 @@
 class StrongJSON
   module Type
-    NONE = ::Object.new
-
     module Match
       def =~(value)
         coerce(value)
@@ -15,8 +13,23 @@ class StrongJSON
       end
     end
 
+    module WithAlias
+      def alias
+        @alias
+      end
+
+      def with_alias(name)
+        _ = dup.tap do |copy|
+          copy.instance_eval do
+            @alias = name
+          end
+        end
+      end
+    end
+
     class Base
       include Match
+      include WithAlias
 
       # @dynamic type
       attr_reader :type
@@ -27,8 +40,6 @@ class StrongJSON
 
       def test(value)
         case @type
-        when :ignored
-          true
         when :any
           true
         when :number
@@ -46,13 +57,10 @@ class StrongJSON
         end
       end
 
-      def coerce(value, path: [])
-        raise Error.new(value: value, type: self, path: path) unless test(value)
-        raise IllegalTypeError.new(type: self) if path == [] && @type == :ignored
+      def coerce(value, path: ErrorPath.root(self))
+        raise TypeError.new(value: value, path: path) unless test(value)
 
         case type
-        when :ignored
-          NONE
         when :symbol
           value.to_sym
         else
@@ -61,32 +69,59 @@ class StrongJSON
       end
 
       def to_s
-        @type.to_s
+        self.alias&.to_s || @type.to_s
+      end
+
+      def ==(other)
+        if other.is_a?(Base)
+          # @type var other: Base<any>
+          other.type == type
+        end
+      end
+
+      __skip__ = begin
+        alias eql? ==
       end
     end
 
     class Optional
       include Match
+      include WithAlias
+
+      # @dynamic type
+      attr_reader :type
 
       def initialize(type)
         @type = type
       end
 
-      def coerce(value, path: [])
-        unless value == nil || NONE.equal?(value)
-          @type.coerce(value, path: path)
+      def coerce(value, path: ErrorPath.root(self))
+        unless value == nil
+          @type.coerce(value, path: path.expand(type: @type))
         else
           nil
         end
       end
 
       def to_s
-        "optional(#{@type})"
+        self.alias&.to_s || "optional(#{@type})"
+      end
+
+      def ==(other)
+        if other.is_a?(Optional)
+          # @type var other: Optional<any>
+          other.type == type
+        end
+      end
+
+      __skip__ = begin
+        alias eql? ==
       end
     end
 
     class Literal
       include Match
+      include WithAlias
 
       # @dynamic value
       attr_reader :value
@@ -96,176 +131,287 @@ class StrongJSON
       end
 
       def to_s
-        "literal(#{@value})"
+        self.alias&.to_s || (_ = @value).inspect
       end
 
-      def coerce(value, path: [])
-        raise Error.new(path: path, type: self, value: value) unless (_ = self.value) == value
+      def coerce(value, path: ErrorPath.root(self))
+        raise TypeError.new(path: path, value: value) unless (_ = self.value) == value
         value
       end
+
+      def ==(other)
+        if other.is_a?(Literal)
+          # @type var other: Literal<any>
+          other.value == value
+        end
+      end
+
+      __skip__ = begin
+        alias eql? ==
+      end
     end
 
     class Array
       include Match
+      include WithAlias
+
+      # @dynamic type
+      attr_reader :type
 
       def initialize(type)
         @type = type
       end
 
-      def coerce(value, path: [])
+      def coerce(value, path: ErrorPath.root(self))
         if value.is_a?(::Array)
           value.map.with_index do |v, i|
-            @type.coerce(v, path: path+[i])
+            @type.coerce(v, path: path.dig(key: i, type: @type))
           end
         else
-          raise Error.new(path: path, type: self, value: value)
+          raise TypeError.new(path: path, value: value)
         end
       end
 
       def to_s
-        "array(#{@type})"
+        self.alias&.to_s || "array(#{@type})"
+      end
+
+      def ==(other)
+        if other.is_a?(Array)
+          # @type var other: Array<any>
+          other.type == type
+        end
+      end
+
+      __skip__ = begin
+        alias eql? ==
       end
     end
 
     class Object
       include Match
+      include WithAlias
 
-      def initialize(fields)
+      # @dynamic fields, ignored_attributes, prohibited_attributes
+      attr_reader :fields, :ignored_attributes, :prohibited_attributes
+
+      def initialize(fields, ignored_attributes:, prohibited_attributes:)
         @fields = fields
+        @ignored_attributes = ignored_attributes
+        @prohibited_attributes = prohibited_attributes
       end
 
-      def coerce(object, path: [])
+      def coerce(object, path: ErrorPath.root(self))
         unless object.is_a?(Hash)
-          raise Error.new(path: path, type: self, value: object)
+          raise TypeError.new(path: path, value: object)
         end
 
-        # @type var result: ::Hash<Symbol, any>
-        result = {}
+        unless (intersection = Set.new(object.keys).intersection(prohibited_attributes)).empty?
+          raise UnexpectedAttributeError.new(path: path, attribute: intersection.to_a.first)
+        end
 
-        object.each do |key, value|
-          unless @fields.key?(key)
-            raise UnexpectedFieldError.new(path: path + [key], value: value)
+        case attrs = ignored_attributes
+        when :any
+          object = object.dup
+          extra_keys = Set.new(object.keys) - Set.new(fields.keys)
+          extra_keys.each do |key|
+            object.delete(key)
+          end
+        when Set
+          object = object.dup
+          attrs.each do |key|
+            object.delete(key)
           end
         end
 
-        @fields.each do |key, type|
-          value = object.key?(key) ? object[key] : NONE
+        # @type var result: ::Hash<Symbol, any>
+        result = {}
 
-          test_value_type(path + [key], type, value) do |v|
-            result[key] = v
+        object.each do |key, _|
+          unless fields.key?(key)
+            raise UnexpectedAttributeError.new(path: path, attribute: key)
           end
         end
 
+        fields.each do |key, type|
+          result[key] = type.coerce(object[key], path: path.dig(key: key, type: type))
+        end
+
         _ = result
       end
 
-      def test_value_type(path, type, value)
-        v = type.coerce(value, path: path)
-
-        return if NONE.equal?(v) || NONE.equal?(type)
-        return if type.is_a?(Optional) && NONE.equal?(value)
-
-        yield(v)
+      def ignore(attrs)
+        Object.new(fields, ignored_attributes: attrs, prohibited_attributes: prohibited_attributes)
       end
 
-      def merge(fields)
-        # @type var fs: Hash<Symbol, _Schema<any>>
+      def ignore!(attrs)
+        @ignored_attributes = attrs
+        self
+      end
 
-        fs = case fields
-             when Object
-               fields.instance_variable_get(:"@fields")
-             when Hash
-               fields
-             end
+      def prohibit(attrs)
+        Object.new(fields, ignored_attributes: ignored_attributes, prohibited_attributes: attrs)
+      end
 
-        Object.new(@fields.merge(fs))
+      def prohibit!(attrs)
+        @prohibited_attributes = attrs
+        self
       end
 
-      def except(*keys)
-        Object.new(keys.each.with_object(@fields.dup) do |key, hash|
-                     hash.delete key
-                   end)
+      def update_fields
+        fields.dup.yield_self do |fields|
+          yield fields
+
+          Object.new(fields, ignored_attributes: ignored_attributes, prohibited_attributes: prohibited_attributes)
+        end
       end
 
       def to_s
-        # @type var fields: ::Array<String>
-        fields = []
+        fields = @fields.map do |name, type|
+          "#{name}: #{type}"
+        end
 
-        @fields.each do |name, type|
-          fields << "#{name}: #{type}"
+        self.alias&.to_s || "object(#{fields.join(', ')})"
+      end
+
+      def ==(other)
+        if other.is_a?(Object)
+          # @type var other: Object<any>
+          other.fields == fields &&
+            other.ignored_attributes == ignored_attributes &&
+            other.prohibited_attributes == prohibited_attributes
         end
+      end
 
-        "object(#{fields.join(', ')})"
+      __skip__ = begin
+        alias eql? ==
       end
     end
 
     class Enum
       include Match
+      include WithAlias
 
-      # @dynamic types
+      # @dynamic types, detector
       attr_reader :types
+      attr_reader :detector
 
-      def initialize(types)
+      def initialize(types, detector = nil)
         @types = types
+        @detector = detector
       end
 
       def to_s
-        "enum(#{types.map(&:to_s).join(", ")})"
+        self.alias&.to_s || "enum(#{types.map(&:to_s).join(", ")})"
       end
 
-      def coerce(value, path: [])
+      def coerce(value, path: ErrorPath.root(self))
+        if d = detector
+          type = d[value]
+          if type && types.include?(type)
+            return type.coerce(value, path: path.expand(type: type))
+          end
+        end
+
         types.each do |ty|
           begin
-            return ty.coerce(value, path: path)
-          rescue UnexpectedFieldError, IllegalTypeError, Error # rubocop:disable Lint/HandleExceptions
+            return ty.coerce(value, path: path.expand(type: ty))
+          rescue UnexpectedAttributeError, TypeError # rubocop:disable Lint/HandleExceptions
           end
         end
 
-        raise Error.new(path: path, type: self, value: value)
+        raise TypeError.new(path: path, value: value)
+      end
+
+      def ==(other)
+        if other.is_a?(Enum)
+          # @type var other: Enum<any>
+          other.types == types &&
+            other.detector == detector
+        end
+      end
+
+      __skip__ = begin
+        alias eql? ==
       end
     end
 
-    class UnexpectedFieldError < StandardError
+    class UnexpectedAttributeError < StandardError
+      # @dynamic path, attribute
+      attr_reader :path, :attribute
+
+      def initialize(path:, attribute:)
+        @path = path
+        @attribute = attribute
+        super "UnexpectedAttributeError at #{path.to_s}: attribute=#{attribute}"
+      end
+
+      def type
+        path.type
+      end
+    end
+
+    class TypeError < StandardError
       # @dynamic path, value
       attr_reader :path, :value
 
-      def initialize(path: , value:)
+      def initialize(path:, value:)
         @path = path
         @value = value
+        type = path.type
+        s = type.alias || type
+        super "TypeError at #{path.to_s}: expected=#{s}, value=#{value.inspect}"
       end
 
-      def to_s
-        position = "#{path.join('.')}"
-        "Unexpected field of #{position} (#{value})"
+      def type
+        path.type
       end
     end
 
-    class IllegalTypeError < StandardError
-      # @dynamic type
-      attr_reader :type
+    class ErrorPath
+      # @dynamic type, parent
+      attr_reader :type, :parent
 
-      def initialize(type:)
+      def initialize(type:, parent:)
         @type = type
+        @parent = parent
       end
 
-      def to_s
-        "#{type} can not be put on toplevel"
+      def dig(key:, type:)
+        # @type var parent: [Integer | Symbol | nil, ErrorPath]
+        parent = [key, self]
+        self.class.new(type: type, parent: parent)
       end
-    end
 
-    class Error < StandardError
-      # @dynamic path, type, value
-      attr_reader :path, :type, :value
+      def expand(type:)
+        # @type var parent: [Integer | Symbol | nil, ErrorPath]
+        parent = [nil, self]
+        self.class.new(type: type, parent: parent)
+      end
 
-      def initialize(path:, type:, value:)
-        @path = path
-        @type = type
-        @value = value
+      def self.root(type)
+        self.new(type: type, parent: nil)
+      end
+
+      def root?
+        !parent
       end
 
       def to_s
-        position = path.empty? ? "" : " at .#{path.join('.')}"
-        "Expected type of value #{value}#{position} is #{type}"
+        if pa = parent
+          if key = pa[0]
+            pa[1].to_s + case key
+                         when Integer
+                           "[#{key}]"
+                         when Symbol
+                           ".#{key}"
+                         end
+          else
+            pa[1].to_s
+          end
+        else
+          "$"
+        end
       end
     end
   end

data/lib/strong_json/types.rb

@@ -2,7 +2,11 @@ class StrongJSON
   module Types
     # @type method object: (?Hash<Symbol, ty>) -> Type::Object<any>
     def object(fields = {})
-      Type::Object.new(fields)
+      if fields.empty?
+        Type::Object.new(fields, ignored_attributes: nil, prohibited_attributes: Set.new)
+      else
+        Type::Object.new(fields, ignored_attributes: :any, prohibited_attributes: Set.new)
+      end
     end
 
     # @type method array: (?ty) -> Type::Array<any>
@@ -39,10 +43,6 @@ class StrongJSON
       optional(any)
     end
 
-    def prohibited
-      StrongJSON::Type::Base.new(:prohibited)
-    end
-
     def symbol
       StrongJSON::Type::Base.new(:symbol)
     end
@@ -51,8 +51,8 @@ class StrongJSON
       StrongJSON::Type::Literal.new(value)
     end
 
-    def enum(*types)
-      StrongJSON::Type::Enum.new(types)
+    def enum(*types, detector: nil)
+      StrongJSON::Type::Enum.new(types, detector)
     end
 
     def string?
@@ -75,15 +75,12 @@ class StrongJSON
       optional(symbol)
     end
 
-    def ignored
-      StrongJSON::Type::Base.new(:ignored)
-    end
-
     def array?(ty)
       optional(array(ty))
     end
 
-    def object?(fields)
+    # @type method object?: (?Hash<Symbol, ty>) -> Type::Optional<any>
+    def object?(fields={})
       optional(object(fields))
     end
 
@@ -91,8 +88,8 @@ class StrongJSON
       optional(literal(value))
     end
 
-    def enum?(*types)
-      optional(enum(*types))
+    def enum?(*types, detector: nil)
+      optional(enum(*types, detector: detector))
     end
   end
 end

data/lib/strong_json/version.rb

@@ -1,5 +1,5 @@
 class StrongJSON
   # @dynamic initialize, let
   
-  VERSION = "0.9.0"
+  VERSION = "1.0.0"
 end

data/lib/strong_json.rb

@@ -1,6 +1,8 @@
 require "strong_json/version"
 require "strong_json/type"
 require "strong_json/types"
+require "strong_json/error_reporter"
+require "prettyprint"
 
 class StrongJSON
   def initialize(&block)
@@ -8,7 +10,7 @@ class StrongJSON
   end
 
   def let(name, type)
-    define_singleton_method(name) { type }
+    define_singleton_method(name) { type.with_alias(name) }
   end
 
   include StrongJSON::Types

data/sig/strong_json.rbi

@@ -6,20 +6,30 @@ end
 
 StrongJSON::VERSION: String
 
+class StandardError
+  def initialize: (String) -> any
+end
+
 interface StrongJSON::_Schema<'type>
-  def coerce: (any, ?path: ::Array<Symbol>) -> 'type
+  def coerce: (any, ?path: Type::ErrorPath) -> 'type
   def =~: (any) -> bool
   def to_s: -> String
   def is_a?: (any) -> bool
+  def alias: -> Symbol?
+  def with_alias: (Symbol) -> self
+  def ==: (any) -> bool
+  def yield_self: <'a> () { (self) -> 'a } -> 'a
 end
 
 type StrongJSON::ty = _Schema<any>
 
 module StrongJSON::Types
   def object: <'x> (Hash<Symbol, ty>) -> Type::Object<'x>
-            | () -> Type::Object<Hash<Symbol, any>>
+            | () -> Type::Object<{}>
   def object?: <'x> (Hash<Symbol, ty>) -> Type::Optional<'x>
+             | () -> Type::Optional<{}>
   def any: () -> Type::Base<any>
+  def any?: () -> Type::Optional<any>
   def optional: <'x> (_Schema<'x>) -> Type::Optional<'x>
               | () -> Type::Optional<any>
   def string: () -> Type::Base<String>
@@ -37,8 +47,17 @@ module StrongJSON::Types
   def array?: <'x> (_Schema<'x>) -> Type::Optional<::Array<'x>>
   def literal: <'x> ('x) -> Type::Literal<'x>
   def literal?: <'x> ('x) -> Type::Optional<'x>
-  def enum: <'x> (*_Schema<any>) -> Type::Enum<'x>
-  def enum?: <'x> (*_Schema<any>) -> Type::Optional<'x>
-  def ignored: () -> _Schema<nil>
-  def prohibited: () -> _Schema<nil>
+  def enum: <'x> (*_Schema<any>, ?detector: Type::detector?) -> Type::Enum<'x>
+  def enum?: <'x> (*_Schema<any>, ?detector: Type::detector?) -> Type::Optional<'x>
+end
+
+class StrongJSON::ErrorReporter
+  attr_reader path: Type::ErrorPath
+  @string: String
+  def initialize: (path: Type::ErrorPath) -> any
+  def format: -> void
+  def (private) format_trace: (path: Type::ErrorPath, ?index: Integer) -> void
+  def (private) format_aliases: (path: Type::ErrorPath, where: ::Array<String>) -> ::Array<String>
+  def (private) pretty: (ty, any, ?expand_alias: bool) -> void
+  def pretty_str: (ty, ?expand_alias: bool) -> ::String
 end