strong_json 1.0.1 → 2.1.2

data/lib/strong_json/types.rb

@@ -1,20 +1,17 @@
 class StrongJSON
   module Types
-    # @type method object: (?Hash<Symbol, ty>) -> Type::Object<any>
     def object(fields = {})
       if fields.empty?
-        Type::Object.new(fields, ignored_attributes: nil, prohibited_attributes: Set.new)
+        Type::Object.new(fields, on_unknown: :ignore, exceptions: Set.new)
       else
-        Type::Object.new(fields, ignored_attributes: :any, prohibited_attributes: Set.new)
+        Type::Object.new(fields, on_unknown: :reject, exceptions: Set.new)
       end
     end
 
-    # @type method array: (?ty) -> Type::Array<any>
     def array(type = any)
       Type::Array.new(type)
     end
 
-    # @type method optional: (?ty) -> Type::Optional<any>
     def optional(type = any)
       Type::Optional.new(type)
     end
@@ -31,6 +28,10 @@ class StrongJSON
       StrongJSON::Type::Base.new(:number)
     end
 
+    def integer
+      StrongJSON::Type::Base.new(:integer)
+    end
+
     def boolean
       StrongJSON::Type::Base.new(:boolean)
     end
@@ -63,6 +64,10 @@ class StrongJSON
       optional(numeric)
     end
 
+    def integer?
+      optional(integer)
+    end
+
     def number?
       optional(number)
     end
@@ -79,7 +84,6 @@ class StrongJSON
       optional(array(ty))
     end
 
-    # @type method object?: (?Hash<Symbol, ty>) -> Type::Optional<any>
     def object?(fields={})
       optional(object(fields))
     end
@@ -91,5 +95,13 @@ class StrongJSON
     def enum?(*types, detector: nil)
       optional(enum(*types, detector: detector))
     end
+
+    def hash(type)
+      StrongJSON::Type::Hash.new(type)
+    end
+
+    def hash?(type)
+      optional(hash(type))
+    end
   end
 end

data/lib/strong_json/version.rb

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

data/pp.rb

@@ -0,0 +1,27 @@
+require "prettyprint"
+
+pp = PrettyPrint.new
+
+pp.group 0 do
+	pp.text "hello = "
+
+	pp.group 0, "enum_____(", ")" do
+		pp.nest(2) do
+			pp.breakable ""
+			count = 7
+			count.times do |i|
+				pp.text "hello #{i}"
+
+				if i < count - 1
+					pp.text ","
+					pp.breakable " "
+				end
+			end
+		end
+
+		pp.breakable ""
+	end
+end
+
+pp.flush
+puts pp.output

data/sig/polyfill.rbs

@@ -0,0 +1,13 @@
+class PrettyPrint
+  def text: (String) -> void
+
+  def group: (?Integer, ?String, ?String) { () -> void } -> void
+
+  def nest: (Integer) { () -> void } -> void
+
+  def breakable: (String) -> void
+
+  def self.format: { (instance) -> void } -> String
+
+  def self.singleline_format: { (instance) -> void } -> String
+end

data/sig/strong_json.rbs

@@ -0,0 +1,67 @@
+class StrongJSON
+  def initialize: { (StrongJSON) -> void } -> untyped
+  def let: (Symbol, ty) -> void
+  include Types
+
+  VERSION: String
+
+  interface _Schema[T]
+    def coerce: (untyped, ?path: Type::ErrorPath) -> T
+    def =~: (untyped) -> bool
+    def to_s: -> String
+    def is_a?: (untyped) -> bool
+    def `alias`: -> Symbol?
+    def with_alias: (Symbol) -> self
+    def ==: (untyped) -> bool
+    def yield_self: [X] () { (self) -> X } -> X
+  end
+
+  type ty = _Schema[untyped]
+
+  module Types
+    def object: [X] (Hash[Symbol, ty]) -> Type::Object[X]
+              | () -> Type::Object[bot]
+    def object?: [X] (Hash[Symbol, ty]) -> Type::Optional[X]
+               | () -> Type::Optional[bot]
+    def any: () -> Type::Base[untyped]
+    def any?: () -> Type::Optional[untyped]
+    def optional: [X] (_Schema[X]) -> Type::Optional[X]
+                | () -> Type::Optional[untyped]
+    def string: () -> Type::Base[String]
+    def string?: () -> Type::Optional[String]
+    def number: () -> Type::Base[Numeric]
+    def number?: () -> Type::Optional[Numeric]
+    def numeric: () -> Type::Base[Numeric]
+    def numeric?: () -> Type::Optional[Numeric]
+    def integer: () -> Type::Base[Integer]
+    def integer?: () -> Type::Optional[Integer]
+    def boolean: () -> Type::Base[bool]
+    def boolean?: () -> Type::Optional[bool]
+    def symbol: () -> Type::Base[Symbol]
+    def symbol?: () -> Type::Optional[Symbol]
+    def array: [X] (_Schema[X]) -> Type::Array[X]
+             | () -> Type::Array[untyped]
+    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[untyped], ?detector: Type::detector?) -> Type::Enum[X]
+    def enum?: [X] (*_Schema[untyped], ?detector: Type::detector?) -> Type::Optional[X]
+    def hash: [X] (_Schema[X]) -> Type::Hash[X]
+    def hash?: [X] (_Schema[X]) -> Type::Optional[Hash[Symbol, X]]
+  end
+
+  class ErrorReporter
+    attr_reader path: Type::ErrorPath
+    @string: String
+
+    def initialize: (path: Type::ErrorPath) -> untyped
+    def format: -> void
+    def pretty_str: (ty, ?expand_alias: bool) -> ::String
+
+    private
+    def format_trace: (path: Type::ErrorPath, ?index: Integer) -> void
+    def format_aliases: (path: Type::ErrorPath, where: ::Array[String]) -> ::Array[String]
+    def format_single_alias: (Symbol, ty) -> String
+    def pretty: (ty, PrettyPrint, ?expand_alias: bool) -> void
+  end
+end

data/sig/type.rbs

@@ -0,0 +1,132 @@
+class StrongJSON
+  module Type
+    module Match : _Schema[untyped]
+      def =~: (untyped) -> bool
+      def ===: (untyped) -> bool
+    end
+
+    module WithAlias : ::Object
+      @alias: Symbol?
+      def `alias`: -> Symbol?
+      def with_alias: (Symbol) -> self
+    end
+
+    type base_type_name = :any | :number | :string | :boolean | :numeric | :symbol | :integer
+
+    class Base[A]
+      include Match
+      include WithAlias
+
+      attr_reader type: base_type_name
+
+      def initialize: (base_type_name) -> untyped
+      def test: (untyped) -> bool
+      def coerce: (untyped, ?path: ErrorPath) -> A
+    end
+
+    class Optional[T]
+      include Match
+      include WithAlias
+
+      attr_reader type: _Schema[T]
+
+      def initialize: (_Schema[T]) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> (T | nil)
+    end
+
+    class Literal[T]
+      include Match
+      include WithAlias
+
+      attr_reader value: T
+
+      def initialize: (T) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> T
+    end
+
+    class Array[T]
+      include Match
+      include WithAlias
+
+      attr_reader type: _Schema[T]
+
+      def initialize: (_Schema[T]) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> ::Array[T]
+    end
+
+    class Object[T]
+      include Match
+      include WithAlias
+
+      attr_reader fields: ::Hash[Symbol, _Schema[untyped]]
+      attr_reader on_unknown: :ignore | :reject
+      attr_reader exceptions: Set[Symbol]
+
+      def initialize: (::Hash[Symbol, _Schema[T]], on_unknown: :ignore | :reject, exceptions: Set[Symbol]) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> T
+
+      # If no argument is given, it ignores all unknown attributes.
+      # If `Symbol`s are given, it ignores the listed attributes, but rejects if other unknown attributes are detected.
+      # If `except:` is specified, it rejects attributes listed in `except` are detected, but ignores other unknown attributes.
+      def ignore: (*Symbol ignores, ?except: Set[Symbol]?) -> Object[T]
+
+      # If no argument is given, it rejects on untyped unknown attribute.
+      # If `Symbol`s are given, it rejects the listed attributes are detected, but ignores other unknown attributes.
+      # If `except:` is specified, it ignores given attributes, but rejects if other unknown attributes are detected.
+      def reject: (*Symbol rejecteds, ?except: Set[Symbol]?) -> Object[T]
+
+      def update_fields: [X] { (::Hash[Symbol, _Schema[untyped]]) -> void } -> Object[X]
+    end
+
+    type detector = ^(untyped) -> _Schema[untyped]?
+
+    class Enum[T]
+      include Match
+      include WithAlias
+
+      attr_reader types: ::Array[_Schema[untyped]]
+      attr_reader detector: detector?
+
+      def initialize: (::Array[_Schema[untyped]], ?detector?) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> T
+    end
+
+    class ErrorPath
+      attr_reader type: _Schema[untyped]
+      attr_reader parent: [Symbol | Integer | nil, ErrorPath]?
+
+      def initialize: (type: _Schema[untyped], parent: [Symbol | Integer | nil, ErrorPath]?) -> untyped
+      def dig: (key: Symbol | Integer, type: _Schema[untyped]) -> ErrorPath
+      def expand: (type: _Schema[untyped]) -> ErrorPath
+
+      def self.root: (_Schema[untyped]) -> ErrorPath
+      def root?: -> bool
+    end
+
+    class TypeError < StandardError
+      attr_reader path: ErrorPath
+      attr_reader value: untyped
+
+      def initialize: (path: ErrorPath, value: untyped) -> untyped
+      def type: -> _Schema[untyped]
+    end
+
+    class UnexpectedAttributeError < StandardError
+      attr_reader path: ErrorPath
+      attr_reader attribute: Symbol
+
+      def initialize: (path: ErrorPath, attribute: Symbol) -> untyped
+      def type: -> _Schema[untyped]
+    end
+
+    class Hash[T]
+      include Match
+      include WithAlias
+
+      attr_reader type: _Schema[T]
+
+      def initialize: (_Schema[T]) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> ::Hash[Symbol, T]
+    end
+  end
+end

data/spec/basetype_spec.rb

@@ -94,6 +94,18 @@ describe StrongJSON::Type::Base do
       end
     end
 
+    context ":integer" do
+      let (:type) { StrongJSON::Type::Base.new(:integer) }
+
+      it "accepts integer" do
+        expect(type.test(123)).to be_truthy
+      end
+
+      it "rejects float" do
+        expect(type.test(1.23)).to be_falsey
+      end
+    end
+
     context ":numeric" do
       let (:type) { StrongJSON::Type::Base.new(:numeric) }
 

data/spec/enum_spec.rb

@@ -29,16 +29,16 @@ describe StrongJSON::Type::Enum do
               id: StrongJSON::Type::Literal.new("id1"),
               value: StrongJSON::Type::Base.new(:string)
             },
-            ignored_attributes: nil,
-            prohibited_attributes: Set.new
+            on_unknown: :reject,
+            exceptions: Set[]
           ),
           StrongJSON::Type::Object.new(
             {
               id: StrongJSON::Type::Base.new(:string),
               value: StrongJSON::Type::Base.new(:symbol)
             },
-            ignored_attributes: nil,
-            prohibited_attributes: Set.new
+            on_unknown: :reject,
+            exceptions: Set[]
           ),
           StrongJSON::Type::Optional.new(StrongJSON::Type::Literal.new(3)),
           StrongJSON::Type::Literal.new(false),
@@ -73,8 +73,8 @@ describe StrongJSON::Type::Enum do
             regexp: StrongJSON::Type::Base.new(:string),
             option: StrongJSON::Type::Base.new(:string),
           },
-          ignored_attributes: nil,
-          prohibited_attributes: Set.new
+          on_unknown: :reject,
+          exceptions: Set[]
         )
       }
 
@@ -83,8 +83,8 @@ describe StrongJSON::Type::Enum do
           {
             literal: StrongJSON::Type::Base.new(:string)
           },
-          ignored_attributes: nil,
-          prohibited_attributes: Set.new
+          on_unknown: :reject,
+          exceptions: Set[]
         )
       }
 

data/spec/hash_spec.rb

@@ -0,0 +1,32 @@
+require "strong_json"
+
+describe StrongJSON::Type::Hash do
+  let(:number) { StrongJSON::Type::Base.new(:number) }
+
+  describe "#coerce" do
+    it "returns a hash" do
+      type = StrongJSON::Type::Hash.new(number)
+      expect(type.coerce({ foo: 123, bar: 234 })).to eq({ foo: 123, bar: 234 })
+    end
+
+    it "raises an error if number is given" do
+      type = StrongJSON::Type::Hash.new(number)
+
+      expect {
+        type.coerce(1)
+      }.to raise_error(StrongJSON::Type::TypeError) {|error|
+        expect(error.path.to_s).to eq("$")
+      }
+    end
+
+    it "raises an error if hash value is unexpected" do
+      type = StrongJSON::Type::Hash.new(number)
+
+      expect {
+        type.coerce({ foo: "hello" })
+      }.to raise_error(StrongJSON::Type::TypeError) {|error|
+        expect(error.path.to_s).to eq("$.foo")
+      }
+    end
+  end
+end

data/spec/json_spec.rb

@@ -3,7 +3,7 @@ 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).ignore(Set.new([:comment]))
+      let :item, object(name: string, count: numeric, price: numeric).ignore(:comment)
       let :items, array(item)
       let :checkout,
           object(items: items,
@@ -20,11 +20,11 @@ describe "StrongJSON.new" do
     end
 
     expect(
-      s.checkout.coerce(items: [{ name: "test", count: 1, price: "2.33", comment: "dummy" }], type: 1)
+      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)
+      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)
@@ -58,7 +58,7 @@ MSG
     }
 
     expect {
-      s.checkout.coerce(items: [], change: "", type: 1)
+      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)
@@ -94,14 +94,14 @@ MSG
       let :enum, object(e1: enum(boolean, number), e2: enum?(literal(1), literal(2)))
     end
 
-    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::TypeError) {|e|
+    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::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{ s.enum.coerce({ e1: false, e2: ""} ) }.to raise_error(StrongJSON::Type::TypeError) {|e|
       expect(e.path.to_s).to eq("$.e2")
     }
   end