strong_json 0.9.0 → 1.0.0

data/sig/type.rbi

@@ -1,89 +1,116 @@
 module StrongJSON::Type
 end
 
-StrongJSON::Type::NONE: any
-
 module StrongJSON::Type::Match: _Schema<any>
   def =~: (any) -> bool
   def ===: (any) -> bool
 end
 
-type StrongJSON::base_type_name = :ignored | :any | :number | :string | :boolean | :numeric | :symbol | :prohibited
+module StrongJSON::Type::WithAlias: ::Object
+  @alias: Symbol?
+  def alias: -> Symbol?
+  def with_alias: (Symbol) -> self
+end
+
+type StrongJSON::base_type_name = :any | :number | :string | :boolean | :numeric | :symbol
 
 class StrongJSON::Type::Base<'a>
   include Match
+  include WithAlias
 
   attr_reader type: base_type_name
 
   def initialize: (base_type_name) -> any
   def test: (any) -> bool
-  def coerce: (any, ?path: ::Array<Symbol>) -> 'a
+  def coerce: (any, ?path: ErrorPath) -> 'a
 end
 
 class StrongJSON::Type::Optional<'t>
   include Match
+  include WithAlias
 
-  @type: _Schema<'t>
+  attr_reader type: _Schema<'t>
 
   def initialize: (_Schema<'t>) -> any
-  def coerce: (any, ?path: ::Array<Symbol>) -> ('t | nil)
+  def coerce: (any, ?path: ErrorPath) -> ('t | nil)
 end
 
 class StrongJSON::Type::Literal<'t>
   include Match
+  include WithAlias
 
   attr_reader value: 't
 
   def initialize: ('t) -> any
-  def coerce: (any, ?path: ::Array<Symbol>) -> 't
+  def coerce: (any, ?path: ErrorPath) -> 't
 end
 
 class StrongJSON::Type::Array<'t>
   include Match
+  include WithAlias
 
-  @type: _Schema<'t>
+  attr_reader type: _Schema<'t>
 
   def initialize: (_Schema<'t>) -> any
-  def coerce: (any, ?path: ::Array<Symbol>) -> ::Array<'t>
+  def coerce: (any, ?path: ErrorPath) -> ::Array<'t>
 end
 
 class StrongJSON::Type::Object<'t>
   include Match
+  include WithAlias
 
-  @fields: Hash<Symbol, _Schema<'t>>
+  attr_reader fields: Hash<Symbol, _Schema<any>>
+  attr_reader ignored_attributes: :any | Set<Symbol> | nil
+  attr_reader prohibited_attributes: Set<Symbol>
 
-  def initialize: (Hash<Symbol, _Schema<'t>>) -> any
-  def coerce: (any, ?path: ::Array<Symbol>) -> 't
-  def test_value_type: <'x, 'y> (::Array<Symbol>, _Schema<'x>, any) { ('x) -> 'y } -> 'y
-  def merge: (Object<any> | Hash<Symbol, _Schema<any>>) -> Object<any>
-  def except: (*Symbol) -> Object<any>
+  def initialize: (Hash<Symbol, _Schema<'t>>, ignored_attributes: :any | Set<Symbol> | nil, prohibited_attributes: Set<Symbol>) -> any
+  def coerce: (any, ?path: ErrorPath) -> 't
+
+  def ignore: (:any | Set<Symbol> | nil) -> self
+  def ignore!: (:any | Set<Symbol> | nil) -> self
+  def prohibit: (Set<Symbol>) -> self
+  def prohibit!: (Set<Symbol>) -> self
+  def update_fields: <'x> { (Hash<Symbol, _Schema<any>>) -> void } -> Object<'x>
 end
 
+type StrongJSON::Type::detector = ^(any) -> _Schema<any>?
+
 class StrongJSON::Type::Enum<'t>
   include Match
+  include WithAlias
 
   attr_reader types: ::Array<_Schema<any>>
+  attr_reader detector: detector?
 
-  def initialize: (::Array<_Schema<any>>) -> any
-  def coerce: (any, ?path: ::Array<Symbol>) -> 't
+  def initialize: (::Array<_Schema<any>>, ?detector?) -> any
+  def coerce: (any, ?path: ErrorPath) -> 't
 end
 
-class StrongJSON::Type::Error
-  attr_reader path: ::Array<Symbol>
-  attr_reader type: ty
-  attr_reader value: any
+class StrongJSON::Type::ErrorPath
+  attr_reader type: _Schema<any>
+  attr_reader parent: [Symbol | Integer | nil, instance]?
+
+  def initialize: (type: _Schema<any>, parent: [Symbol | Integer | nil, instance]?) -> any
+  def (constructor) dig: (key: Symbol | Integer, type: _Schema<any>) -> self
+  def (constructor) expand: (type: _Schema<any>) -> self
 
-  def initialize: (path: ::Array<Symbol>, type: ty, value: any) -> any
+  def self.root: (_Schema<any>) -> instance
+  def root?: -> bool
 end
 
-class StrongJSON::Type::UnexpectedFieldError
-  attr_reader path: ::Array<Symbol>
+class StrongJSON::Type::TypeError < StandardError
+  attr_reader path: ErrorPath
   attr_reader value: any
 
-  def initialize: (path: ::Array<Symbol>, value: any) -> any
+  def initialize: (path: ErrorPath, value: any) -> any
+  def type: -> _Schema<any>
 end
 
-class StrongJSON::Type::IllegalTypeError
-  attr_reader type: ty
-  def initialize: (type: ty) -> any
+class StrongJSON::Type::UnexpectedAttributeError < StandardError
+  attr_reader path: ErrorPath
+  attr_reader attribute: Symbol
+
+  def initialize: (path: ErrorPath, attribute: Symbol) -> any
+  def type: -> _Schema<any>
 end
+

data/spec/array_spec.rb

@@ -21,19 +21,19 @@ describe StrongJSON::Type::Array, "#coerce" do
   it "reject non array" do
     type = StrongJSON::Type::Array.new(StrongJSON::Type::Base.new(:number))
 
-    expect { type.coerce({}) }.to raise_error(StrongJSON::Type::Error)
+    expect { type.coerce({}) }.to raise_error(StrongJSON::Type::TypeError)
   end
 
   it "reject membership" do
     type = StrongJSON::Type::Array.new(StrongJSON::Type::Base.new(:number))
 
-    expect { type.coerce(["a"]) }.to raise_error(StrongJSON::Type::Error)
+    expect { type.coerce(["a"]) }.to raise_error(StrongJSON::Type::TypeError)
   end
 
   it "rejects nil" do
     type = StrongJSON::Type::Array.new(StrongJSON::Type::Base.new(:number))
 
-    expect { type.coerce(nil) }.to raise_error(StrongJSON::Type::Error)
+    expect { type.coerce(nil) }.to raise_error(StrongJSON::Type::TypeError)
   end
 
   describe "=~" do

data/spec/basetype_spec.rb

@@ -2,14 +2,6 @@ require "strong_json"
 
 describe StrongJSON::Type::Base do
   describe "#test" do
-    context ":ignored" do
-      let (:type) { StrongJSON::Type::Base.new(:ignored) }
-
-      it "can not be placed on toplevel" do
-        expect { type.coerce(3, path: []) }.to raise_error(StrongJSON::Type::IllegalTypeError)
-      end
-    end
-
     context ":number" do
       let (:type) { StrongJSON::Type::Base.new(:number) }
       
@@ -178,4 +170,20 @@ describe StrongJSON::Type::Base do
       end
     end
   end
+
+  describe "alias" do
+    let (:type) { StrongJSON::Type::Base.new(:number) }
+
+    it "returns nil" do
+      expect(type.alias).to be_nil
+    end
+
+    describe "with_alias" do
+      let (:aliased_type) { type.with_alias(:count) }
+
+      it "returns alias name" do
+        expect(aliased_type.alias).to eq(:count)
+      end
+    end
+  end
 end

data/spec/enum_spec.rb

@@ -22,14 +22,28 @@ describe StrongJSON::Type::Enum do
 
   describe "#coerce" do
     let (:type) {
-      StrongJSON::Type::Enum.new([
-                                   StrongJSON::Type::Object.new(id: StrongJSON::Type::Literal.new("id1"),
-                                                                value: StrongJSON::Type::Base.new(:string)),
-                                   StrongJSON::Type::Object.new(id: StrongJSON::Type::Base.new(:string),
-                                                                value: StrongJSON::Type::Base.new(:symbol)),
-                                   StrongJSON::Type::Optional.new(StrongJSON::Type::Literal.new(3)),
-                                   StrongJSON::Type::Literal.new(false),
-                                 ])
+      StrongJSON::Type::Enum.new(
+        [
+          StrongJSON::Type::Object.new(
+            {
+              id: StrongJSON::Type::Literal.new("id1"),
+              value: StrongJSON::Type::Base.new(:string)
+            },
+            ignored_attributes: nil,
+            prohibited_attributes: Set.new
+          ),
+          StrongJSON::Type::Object.new(
+            {
+              id: StrongJSON::Type::Base.new(:string),
+              value: StrongJSON::Type::Base.new(:symbol)
+            },
+            ignored_attributes: nil,
+            prohibited_attributes: Set.new
+          ),
+          StrongJSON::Type::Optional.new(StrongJSON::Type::Literal.new(3)),
+          StrongJSON::Type::Literal.new(false),
+        ]
+      )
     }
 
     it "returns object with string value" do
@@ -49,7 +63,71 @@ describe StrongJSON::Type::Enum do
     end
 
     it "raises error" do
-      expect { type.coerce(3.14) }.to raise_error(StrongJSON::Type::Error)
+      expect { type.coerce(3.14) }.to raise_error(StrongJSON::Type::TypeError)
+    end
+
+    context "with detector" do
+      let(:regexp_pattern) {
+        StrongJSON::Type::Object.new(
+          {
+            regexp: StrongJSON::Type::Base.new(:string),
+            option: StrongJSON::Type::Base.new(:string),
+          },
+          ignored_attributes: nil,
+          prohibited_attributes: Set.new
+        )
+      }
+
+      let(:literal_pattern) {
+        StrongJSON::Type::Object.new(
+          {
+            literal: StrongJSON::Type::Base.new(:string)
+          },
+          ignored_attributes: nil,
+          prohibited_attributes: Set.new
+        )
+      }
+
+      let(:type) {
+        StrongJSON::Type::Enum.new(
+          [
+            regexp_pattern,
+            literal_pattern,
+            StrongJSON::Type::Base.new(:string),
+          ],
+          -> (value) {
+            case value
+            when Hash
+              case
+              when value.key?(:regexp)
+                regexp_pattern
+              when value.key?(:literal)
+                literal_pattern
+              end
+            end
+          }
+        )
+      }
+
+      it "accepts regexp pattern" do
+        expect(type.coerce({ regexp: "foo", option: "x" })).to eq({regexp: "foo", option: "x"})
+      end
+
+      it "raises error with base type" do
+        expect {
+          type.coerce({ regexp: "foo", option: 123 })
+        }.to raise_error(StrongJSON::Type::TypeError) {|x|
+          expect(x.type).to be_a(StrongJSON::Type::Base)
+        }
+      end
+
+      it "raises error with enum type" do
+        expect {
+          type.coerce({ option: 3 })
+        }.to raise_error(StrongJSON::Type::TypeError) {|x|
+          expect(x.type).to eq(type)
+        }
+      end
     end
   end
 end

data/spec/error_spec.rb

@@ -1,8 +1,66 @@
-describe StrongJSON::Type::Error do
+require "strong_json"
+
+describe StrongJSON::Type::ErrorPath do
+  ErrorPath = StrongJSON::Type::ErrorPath
   include StrongJSON::Types
 
-  it "hgoehoge" do
-    exn = StrongJSON::Type::Error.new(value: [], type: array(numeric), path: ["a",1,"b"])
-    expect(exn.to_s).to be_a(String)
+  describe "root path" do
+    let(:path) { ErrorPath.root(string) }
+
+    it "does not have parent" do
+      expect(path.parent).to be_nil
+    end
+
+    it "has type" do
+      expect(path.type).to be_a(StrongJSON::Type::Base)
+    end
+
+    it "prints" do
+      expect(path.to_s).to eq("$")
+    end
+  end
+
+  describe "appended path" do
+    let(:path) {
+      ErrorPath.root(object(foo: array(number)))
+        .dig(key: :foo, type: array(number))
+        .dig(key: 0, type: number)
+    }
+
+    it "does have parent" do
+      expect(path.parent).to be_a(Array)
+      expect(path.parent[0]).to eq(0)
+      expect(path.parent[1]).to be_a(ErrorPath)
+    end
+
+    it "has type" do
+      expect(path.type).to be_a(StrongJSON::Type::Base)
+    end
+
+    it "prints" do
+      expect(path.to_s).to eq("$.foo[0]")
+    end
+  end
+
+  describe "expanded path" do
+    let(:path) {
+      ErrorPath.root(array(enum(number, string)))
+        .dig(key: 0, type: enum(number, string))
+        .expand(type: string)
+    }
+
+    it "does have parent" do
+      expect(path.parent).to be_a(Array)
+      expect(path.parent[0]).to be_nil
+      expect(path.parent[1]).to be_a(ErrorPath)
+    end
+
+    it "has type" do
+      expect(path.type).to be_a(StrongJSON::Type::Base)
+    end
+
+    it "prints" do
+      expect(path.to_s).to eq("$[0]")
+    end
   end
 end

data/spec/json_spec.rb

@@ -3,11 +3,90 @@ require "strong_json"
 describe "StrongJSON.new" do
   it "tests the structure of a JSON object" do
     s = StrongJSON.new do
-      let :item, object(name: string, count: numeric, price: numeric, comment: ignored)
-      let :checkout, object(items: array(item), change: optional(number), type: enum(literal(1), symbol))
+      let :item, object(name: string, count: numeric, price: numeric).ignore(Set.new([:comment]))
+      let :items, array(item)
+      let :checkout,
+          object(items: items,
+                 change: optional(number),
+                 type: enum(literal(1), symbol),
+                 customer: object?(
+                   name: string,
+                   id: string,
+                   birthday: string,
+                   gender: enum(literal("man"), literal("woman"), literal("other")),
+                   phone: string
+                 )
+          )
     end
 
-    expect(s.checkout.coerce(items: [ { name: "test", count: 1, price: "2.33", comment: "dummy" }], type: 1)).to eq(items: [ { name: "test", count: 1, price: "2.33" }], type: 1)
+    expect(
+      s.checkout.coerce(items: [{ name: "test", count: 1, price: "2.33", comment: "dummy" }], type: 1)
+    ).to eq(items: [ { name: "test", count: 1, price: "2.33" }], type: 1, change: nil, customer: nil)
+
+    expect {
+      s.checkout.coerce(items: [{ name: "test", count: 1, price: [], comment: "dummy" }], type: 1)
+    }.to raise_error(StrongJSON::Type::TypeError) {|e|
+      expect(e.path.to_s).to eq("$.items[0].price")
+      expect(e.type).to be_a(StrongJSON::Type::Base)
+
+      expect(e.message).to eq("TypeError at $.items[0].price: expected=numeric, value=[]")
+      reporter = StrongJSON::ErrorReporter.new(path: e.path)
+      expect(reporter.to_s).to eq(<<MSG.chop)
+ "price" expected to be numeric
+  0 expected to be item
+   "items" expected to be items
+    $ expected to be checkout
+
+Where:
+  item = { "name": string, "count": numeric, "price": numeric }
+  items = array(item)
+  checkout = {
+    "items": items,
+    "change": optional(number),
+    "type": enum(1, symbol),
+    "customer": optional(
+      {
+        "name": string,
+        "id": string,
+        "birthday": string,
+        "gender": enum("man", "woman", "other"),
+        "phone": string
+      }
+    )
+  }
+MSG
+    }
+
+    expect {
+      s.checkout.coerce(items: [], change: "", type: 1)
+    }.to raise_error(StrongJSON::Type::TypeError) {|e|
+      expect(e.path.to_s).to eq("$.change")
+      expect(e.type).to be_a(StrongJSON::Type::Base)
+
+      expect(e.message).to eq('TypeError at $.change: expected=number, value=""')
+      reporter = StrongJSON::ErrorReporter.new(path: e.path)
+      expect(reporter.to_s).to eq(<<MSG.chop)
+ Expected to be number
+  "change" expected to be optional(number)
+   $ expected to be checkout
+
+Where:
+  checkout = {
+    "items": items,
+    "change": optional(number),
+    "type": enum(1, symbol),
+    "customer": optional(
+      {
+        "name": string,
+        "id": string,
+        "birthday": string,
+        "gender": enum("man", "woman", "other"),
+        "phone": string
+      }
+    )
+  }
+MSG
+    }
   end
 
   it "tests enums" do
@@ -15,11 +94,58 @@ describe "StrongJSON.new" do
       let :enum, object(e1: enum(boolean, number), e2: enum?(literal(1), literal(2)))
     end
 
-    expect(s.enum.coerce(e1: false)).to eq(e1: false)
-    expect(s.enum.coerce(e1: 0)).to eq(e1: 0)
+    expect(s.enum.coerce(e1: false)).to eq(e1: false, e2: nil)
+    expect(s.enum.coerce(e1: 0)).to eq(e1: 0, e2: nil)
     expect(s.enum.coerce(e1: 0, e2: 1)).to eq(e1: 0, e2: 1)
     expect(s.enum.coerce(e1: 0, e2: 2)).to eq(e1: 0, e2: 2)
-    expect{ s.enum.coerce(e1: "", e2: 3) }.to raise_error(StrongJSON::Type::Error)
-    expect{ s.enum.coerce(e1: false, e2: "") }.to raise_error(StrongJSON::Type::Error)
+    expect{ s.enum.coerce(e1: "", e2: 3) }.to raise_error(StrongJSON::Type::TypeError) {|e|
+      expect(e.path.to_s).to eq("$.e1")
+    }
+    expect{ s.enum.coerce(e1: false, e2: "") }.to raise_error(StrongJSON::Type::TypeError) {|e|
+      expect(e.path.to_s).to eq("$.e2")
+    }
+  end
+
+  describe "#let" do
+    it "defines aliased type" do
+      s = StrongJSON.new do
+        let :count, number
+        let :age, number
+      end
+
+      expect(s.count.alias).to eq(:count)
+      expect(s.age.alias).to eq(:age)
+    end
+  end
+
+  it "pretty print" do
+    s = StrongJSON.new do
+      let :regexp_pattern, object(pattern: string, multiline: boolean?, case_sensitive: boolean?)
+      let :token_pattern, object(token: string, case_sensitive: boolean?)
+      let :literal_pattern, object(literal: string)
+      let :string_pattern, string
+      let :pattern, enum(regexp_pattern, token_pattern, literal_pattern, string_pattern, string?)
+
+      let :rule, object(pattern: pattern, glob: enum?(string, array(string)))
+    end
+
+    expect { s.rule.coerce({ pattern: { pattern: 3 } }) }.to raise_error(StrongJSON::Type::TypeError) {|e|
+      expect(e.message).to eq("TypeError at $.pattern: expected=pattern, value={:pattern=>3}")
+      reporter = StrongJSON::ErrorReporter.new(path: e.path)
+      expect(reporter.to_s).to eq(<<MSG.chop)
+ "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))) }
+MSG
+    }
   end
 end