strong_json 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34cb280b80e097153297adf6032193ce6479c3facb6aabf8f8bf0794a83030e0
-  data.tar.gz: 12e64c35a8376a275d6cf0e4819c2820d5f5db4fa94b1b294ecba2ccd133fd42
+  metadata.gz: fdd0f07ab15fb780a80f1f1aa00ca73cf253d3fd1dc606548c17c3044d53aba8
+  data.tar.gz: 9b6928be45c28fd0f25cefdeccbcdcadd60d9f5cf4dd08641ec1d913928f61a8
 SHA512:
-  metadata.gz: 3258f86f9fe623a016658fc19a8f333a60fb99a9af4a9d55c23087e4bcf3edb137723083921d4f55ed5764dd659e964a0b4afbbf36cf4e9294247bf5a377fdbb
-  data.tar.gz: f52cfe275312e777495d5d5d7d2822aeec61fb5cedcc01573c630ce34c204861072e996bd4ee9c621121cb97a83aed27642ec2bc035df4e4c87d551d35acc449
+  metadata.gz: 0e0d57e0a35ade9741f5f2b4b53d86dc56f8175a06da3c12c2d09751c23c0f2696e97f1e9439949ecdf924208eb1d779bc6fc0f8d83b71e19e4799d3fd8b8124
+  data.tar.gz: eecb31e269885a382c90be9ec8988b5b2cfef7c39f5669e1f0d1be90507742259359a4f74cbcadebc4db5817ef2901a375efe2792e58fac00a9d332638690832

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 1.0.0 (2019-05-26)
+
+* [#14](https://github.com/soutaro/strong_json/pull/14): Revise error reporting
+
 ## 0.9.0 (2019-3-20)
 
 * [#12](https://github.com/soutaro/strong_json/pull/12): Fix type signature

data/README.md

@@ -57,25 +57,29 @@ If an attribute has a value which does not match with given type, the `coerce` m
 * Fields, `f1`, `f2`, and ..., must be present and its values must be of `type1`, `type2`, ..., respectively
 * Objects with other fields will be rejected
 
-#### Performance hint
+#### Ignoring unknown attributes
 
-Object attributes test is done in order of the keys.
+`Object` type ignores unknown attributes by default.
+You can reject the unknown attributes.
 
-```ruby
-slower_object = enum(
-  object(id: numeric, created_at: string, updated_at: string, type: literal("person"), name: string),
-  object(id: numeric, created_at: string, updated_at: string, type: literal("food"), object: any)
-)
+```
+object(attrs).ignore(Set.new)       # Ignores nothing (== raise an error)
+object(attrs).ignore!(Set.new)      # Destructive version
+```
 
-faster_object = enum(
-  object(type: literal("person"), id: numeric, created_at: string, updated_at: string, name: string),
-  object(type: literal("food"), id: numeric, created_at: string, updated_at: string, object: any)
-)
+You can selectively ignore attributes:
+
+```
+object(attrs).ignore(Set.new([:a, :b, :c]))   # Ignores only :a, :b, and :c
+object(attrs).ignore(:any)                    # Ignores everything (default)
 ```
 
-The two enums represents same object, but testing runs faster with `faster_object`.
-Objects in `faster_object` have `type` attribute as their first keys.
-Testing `type` is done first, and it soon determines if the object is `"person"` or `"food"`.
+`Object` also has `prohibit` method to specify attributes to make the type check failed.
+
+```
+object(attrs).prohibit(Set.new([:created_at, :updated_at]))   # Make type check failed if :created_at or :updated_at included
+object(attrs).prohibit!(Set.new([:created_at, :updated_at]))  # Destructive version
+```
 
 ### array(type)
 
@@ -92,6 +96,25 @@ Testing `type` is done first, and it soon determines if the object is `"person"`
 * The value can be one of the given types
 * First successfully coerced value will return
 
+#### `detector` keyword
+
+`enum` has optional keyword argument `detector`, which helps identify the type of value.
+
+```rb
+enum(person,
+     contact,
+     detector: -> (value) {
+       if value.is_a?(Hash)
+         case
+         when value[:type] == "person"
+           person
+         when value[:type] == "contact"
+           contact
+         end
+       end
+     })
+```
+
 ### Base types
 
 * `number` The value must be an instance of `Numeric`
@@ -99,7 +122,6 @@ Testing `type` is done first, and it soon determines if the object is `"person"`
 * `boolean` The value must be `true` or `false`
 * `numeric` The value must be an instance of `Numeric` or a string which represents a number
 * `any` Any value except `nil` is accepted
-* `ignored` Any value will be ignored
 * `symbol` The value must be an instance of `String` or `Symbol`; returns the result ot `#to_sym`
 
 ### Literals
@@ -116,7 +138,6 @@ There are some alias for `optional(base)`, where base is base types, as the foll
 * `numeric?`
 * `symbol?`
 * `literal?(lit)`
-* `any?`
 
 Shortcuts for complex data are also defined as the following:
 
@@ -124,6 +145,37 @@ Shortcuts for complex data are also defined as the following:
 * `optional(object(fields))` → `object?(fields)`
 * `optional(enum(types))` → `enum?(types)`
 
+## ErrorReporter
+
+You can pretty print type error using `ErrorReporter`.
+
+```rb
+begin
+  type_check()
+rescue StrongJSON::TypeError, StrongJSON::UnexpectedAttributeError => exn
+  puts exn.message
+  puts StrongJSON::ErrorReporter.new(path: exn.path).to_s
+end
+```
+
+It will print a _user-friendly_ error message like:
+
+```
+TypeError at $.pattern: expected=pattern, value={:pattern=>3}
+ "pattern" expected to be pattern
+  $ expected to be rule
+
+Where:
+  pattern = enum(
+    regexp_pattern,
+    token_pattern,
+    literal_pattern,
+    string_pattern,
+    optional(string)
+  )
+  rule = { "pattern": pattern, "glob": optional(enum(string, array(string))) }
+```
+
 ## Type checking
 
 StrongJSON ships with type definitions for [Steep](https://github.com/soutaro/steep).

data/lib/strong_json/error_reporter.rb

@@ -0,0 +1,130 @@
+class StrongJSON
+  class ErrorReporter
+    # @dynamic path
+    attr_reader :path
+
+    def initialize(path:)
+      @path = path
+    end
+
+    def to_s
+      format() unless @string
+      @string
+    end
+
+    def format
+      @string = ""
+
+      format_trace(path: path)
+      where = format_aliases(path: path, where: [])
+      unless where.empty?
+        @string << "\nWhere:\n"
+        @string << where.map {|x| x.gsub(/^/, "  ") }.join("\n")
+      end
+    end
+
+    def format_trace(path:, index: 1)
+      @string << (" " * index)
+      type_string = pretty_str(path.type)
+      if parent = path.parent
+        case parent[0]
+        when Symbol
+          @string << "\"#{parent[0]}\" expected to be #{type_string}\n"
+        when Integer
+          @string << "#{parent[0]} expected to be #{type_string}\n"
+        else
+          @string << "Expected to be #{type_string}\n"
+        end
+
+        format_trace(path: parent[1], index: index + 1)
+      else
+        @string << "$ expected to be #{type_string}\n"
+      end
+    end
+
+    def format_aliases(path:, where:)
+      ty = path.type
+
+      if ty.alias
+        # @type const PrettyPrint: any
+        where << PrettyPrint.format do |pp|
+          pp.text(ty.alias.to_s)
+          pp.text(" = ")
+          pp.group do
+            pretty(ty, pp, expand_alias: true)
+          end
+        end
+      end
+
+      if parent = path.parent
+        format_aliases(path: parent[1], where: where)
+      end
+
+      where
+    end
+
+    def pretty_str(type, expand_alias: false)
+      # @type const PrettyPrint: any
+      PrettyPrint.singleline_format do |pp|
+        pretty(type, pp, expand_alias: expand_alias)
+      end
+    end
+
+    def pretty(type, pp, expand_alias: false)
+      if !expand_alias && type.alias
+        pp.text type.alias.to_s
+      else
+        case type
+        when Type::Object
+          pp.group 0, "{", "}" do
+            pp.nest(2) do
+              pp.breakable(" ")
+              type.fields.each.with_index do |pair, index|
+                key, ty = pair
+                pp.text "#{key.to_s.inspect}: "
+                pretty(ty, pp)
+                if index < type.fields.size-1
+                  pp.text ","
+                  pp.breakable(" ")
+                end
+              end
+            end
+            pp.breakable(" ")
+          end
+        when Type::Enum
+          pp.group 0, "enum(", ")" do
+            pp.nest(2) do
+              pp.breakable("")
+              type.types.each.with_index do |ty, index|
+                pretty(ty, pp)
+                if index < type.types.size - 1
+                  pp.text ","
+                  pp.breakable " "
+                end
+              end
+            end
+            pp.breakable("")
+          end
+        when Type::Optional
+          pp.group 0, "optional(", ")" do
+            pp.nest(2) do
+              pp.breakable ""
+              pretty(type.type, pp)
+            end
+            pp.breakable ""
+          end
+        when Type::Array
+          pp.group 0, "array(", ")" do
+            pp.nest(2) do
+              pp.breakable ""
+              pretty(type.type, pp)
+            end
+            pp.breakable ""
+          end
+        else
+          pp.text type.to_s
+        end
+      end
+    end
+  end
+end