strong_json 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b38c3654e379c46a4b5567f8c256c72da14ca8efa3bd64deef2b56c4e037957d
-  data.tar.gz: b3b3832aa8b1e76a84c2210234f34b8abcecc02a3d42848ae871e648f41e35f8
+  metadata.gz: 2ddde917e3030412ba154b0b99ea307e2c50af8ff9ca7b45ba9730e96d6dfff0
+  data.tar.gz: a0fbfc9b8245dae4683236e1c6d5b92c97b5ce30ad4eef628e54bde56539f47c
 SHA512:
-  metadata.gz: c2a949f49b357ffa0496bf1d6646d57190b6c26633ce604ef2cb30f6faf72b9d89de3b88172dac22776914b053eb5081c80a75bbdbf88217d1ff04d3bfdfe3c8
-  data.tar.gz: d74c050d81ee145056978925f475e216692c107536258306857b4379288318930fafecce803d9e02454cd7997ab3b925005019ddad6a098a9750c0db7b0276cf
+  metadata.gz: a2051a77f37d08d171ad355ae97fdd0b46bf42fbaaa771824f3cff3be4e0498e1a3844881036e6877981ae44852eee89347894768e86b28d49a44d73c9c8867c
+  data.tar.gz: 460f595197f2772851bcf4e400ca08bd7410a797cc2161dc39e7f35526211f508b0940ee2733b5ba07d661b43a5ccbd535599debd722e0f5115eaf795c53a5f9

data/.travis.yml

@@ -1,5 +1,3 @@
 language: ruby
 rvm:
-  - "2.3.3"
-  - "2.4.1"
-  - "2.5.1"
+  - "2.5.3"

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# CHANGELOG
+
+## master
+
+## 0.8.0 (2018-10-29)
+
+* Add steep typechecking

data/README.md

@@ -124,6 +124,59 @@ Shortcuts for complex data are also defined as the following:
 * `optional(object(fields))` → `object?(fields)`
 * `optional(enum(types))` → `enum?(types)`
 
+## Type checking
+
+StrongJSON ships with type definitions for [Steep](https://github.com/soutaro/steep).
+You can type check your programs using StrongJSON by Steep.
+
+### Type definition
+
+Define your types as the following.
+
+```
+class JSONSchema::Account < StrongJSON
+  def account: -> StrongJSON::_Schema<{ id: Integer, name: String }>
+end
+
+Schema: JSONSchema::Account
+```
+
+And write your schema definition as the following.
+
+```rb
+Schema = _ = StrongJSON.new do
+  # @type self: JSONSchema::Account
+
+  let :account, object(id: number, name: string)
+end
+
+id = Schema.account.coerce(hash)[:id]       # id is Integer
+name = Schema.account.coerce(hash)[:name]   # name is String
+```
+
+Note that you need two tricks:
+
+* A cast `_ = StrongJSON.new ...` on assignment to `Schema` constant
+* A `@type self` annotation in the block
+
+See the `example` directory.
+
+### Commandline
+
+Steep 0.8.1 supports loading type definitions from gems.
+
+Pass `-G` option to type check your program.
+
+```
+$ steep check -G strong_json lib
+```
+
+When you are using `bundler`, it automatically detects that StrongJSON has type definitions.
+
+```
+$ bundle exec steep check lib
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/soutaro/strong_json/fork )

data/Rakefile

@@ -3,4 +3,14 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task :default => [:spec, :typecheck, :"example:typecheck"]
+
+task :typecheck do
+  sh "bundle exec steep check --strict lib"
+end
+
+namespace :example do
+  task :typecheck do
+    sh "bundle exec steep check --strict -I sig -I example example"
+  end
+end

data/example/example.rb

@@ -0,0 +1,27 @@
+Schema = _ = StrongJSON.new do
+  # @type self: AddressSchema
+
+  let :address, object(address: string, country: symbol?)
+  let :email, object(email: string)
+  let :contact, enum(address, email)
+  let :person, object(name: string, contacts: array(contact))
+end
+
+person = Schema.person.coerce(nil)
+
+# @type var name: String
+name = person[:name]
+
+# @type var contacts: Array<email | address>
+contacts = person[:contacts]
+
+contacts.each do |contact|
+    case 
+    when contact.keys.include?(:email)
+        # @type var contact: email
+        puts "Email: #{contact[:email]}"
+    when contact.keys.include?(:address)
+        # @type var contact: address
+        puts "Address: #{contact[:address]} (#{contact[:country] || "unspecified"})"
+    end
+end

data/example/example.rbi

@@ -0,0 +1,11 @@
+type address = { address: String, country: Symbol? }
+type email = { email: String }
+
+class AddressSchema < StrongJSON
+  def address: -> StrongJSON::_Schema<address>
+  def email: -> StrongJSON::_Schema<email>
+  def contact: -> StrongJSON::_Schema<email | address>
+  def person: -> StrongJSON::_Schema<{ name: String, contacts: Array<email | address> }>
+end
+
+Schema: AddressSchema

data/lib/strong_json/type.rb

@@ -18,6 +18,7 @@ class StrongJSON
     class Base
       include Match
 
+      # @dynamic type
       attr_reader :type
 
       def initialize(type)
@@ -87,6 +88,7 @@ class StrongJSON
     class Literal
       include Match
 
+      # @dynamic value
       attr_reader :value
 
       def initialize(value)
@@ -98,7 +100,7 @@ class StrongJSON
       end
 
       def coerce(value, path: [])
-        raise Error.new(path: path, type: self, value: value) unless self.value == value
+        raise Error.new(path: path, type: self, value: value) unless (_ = self.value) == value
         value
       end
     end
@@ -137,6 +139,7 @@ class StrongJSON
           raise Error.new(path: path, type: self, value: object)
         end
 
+        # @type var result: ::Hash<Symbol, any>
         result = {}
 
         object.each do |key, value|
@@ -153,7 +156,7 @@ class StrongJSON
           end
         end
 
-        result
+        _ = result
       end
 
       def test_value_type(path, type, value)
@@ -166,11 +169,16 @@ class StrongJSON
       end
 
       def merge(fields)
-        if fields.is_a?(Object)
-          fields = fields.instance_variable_get("@fields")
-        end
+        # @type var fs: Hash<Symbol, _Schema<any>>
+
+        fs = case fields
+             when Object
+               fields.instance_variable_get(:"@fields")
+             when Hash
+               fields
+             end
 
-        Object.new(@fields.merge(fields))
+        Object.new(@fields.merge(fs))
       end
 
       def except(*keys)
@@ -180,6 +188,7 @@ class StrongJSON
       end
 
       def to_s
+        # @type var fields: ::Array<String>
         fields = []
 
         @fields.each do |name, type|
@@ -193,6 +202,7 @@ class StrongJSON
     class Enum
       include Match
 
+      # @dynamic types
       attr_reader :types
 
       def initialize(types)
@@ -216,6 +226,7 @@ class StrongJSON
     end
 
     class UnexpectedFieldError < StandardError
+      # @dynamic path, value
       attr_reader :path, :value
 
       def initialize(path: , value:)
@@ -230,6 +241,7 @@ class StrongJSON
     end
 
     class IllegalTypeError < StandardError
+      # @dynamic type
       attr_reader :type
 
       def initialize(type:)
@@ -242,6 +254,7 @@ class StrongJSON
     end
 
     class Error < StandardError
+      # @dynamic path, type, value
       attr_reader :path, :type, :value
 
       def initialize(path:, type:, value:)

data/lib/strong_json/types.rb

@@ -1,13 +1,16 @@
 class StrongJSON
   module Types
+    # @type method object: (?Hash<Symbol, ty>) -> _Schema<any>
     def object(fields = {})
       Type::Object.new(fields)
     end
 
+    # @type method array: (?ty) -> _Schema<any>
     def array(type = any)
       Type::Array.new(type)
     end
 
+    # @type method optional: (?ty) -> _Schema<any>
     def optional(type = any)
       Type::Optional.new(type)
     end

data/lib/strong_json/version.rb

@@ -1,3 +1,5 @@
 class StrongJSON
-  VERSION = "0.7.1"
+  # @dynamic initialize, let
+  
+  VERSION = "0.8.0"
 end

data/sig/strong_json.rbi

@@ -0,0 +1,44 @@
+class StrongJSON
+  def initialize: { (self) -> void } -> any
+  def let: (Symbol, ty) -> void
+  include StrongJSON::Types
+end
+
+StrongJSON::VERSION: String
+
+interface StrongJSON::_Schema<'type>
+  def coerce: (any, ?path: ::Array<Symbol>) -> 'type
+  def =~: (any) -> bool
+  def to_s: -> String
+  def is_a?: (any) -> bool
+end
+
+type StrongJSON::ty = _Schema<any>
+
+module StrongJSON::Types
+  def object: <'x> (Hash<Symbol, ty>) -> _Schema<'x>
+            | () -> _Schema<Hash<Symbol, any>>
+  def object?: <'x> (Hash<Symbol, ty>) -> _Schema<'x | nil>
+  def any: () -> _Schema<any>
+  def optional: <'x> (?_Schema<'x>) -> _Schema<'x | nil>
+              | () -> _Schema<any>
+  def string: () -> _Schema<String>
+  def string?: () -> _Schema<String?>
+  def number: () -> _Schema<Numeric>
+  def number?: () -> _Schema<Numeric?>
+  def numeric: () -> _Schema<Numeric>
+  def numeric?: () -> _Schema<Numeric?>
+  def boolean: () -> _Schema<bool>
+  def boolean?: () -> _Schema<bool?>
+  def symbol: () -> _Schema<Symbol>
+  def symbol?: () -> _Schema<Symbol?>
+  def array: <'x> (_Schema<'x>) -> _Schema<Array<'x>>
+           | () -> _Schema<Array<any>>
+  def array?: <'x> (_Schema<'x>) -> _Schema<Array<'x>?>
+  def literal: <'x> ('x) -> _Schema<'x>
+  def literal?: <'x> ('x) -> _Schema<'x?>
+  def enum: <'x> (*_Schema<any>) -> _Schema<'x>
+  def enum?: <'x> (*_Schema<any>) -> _Schema<'x?>
+  def ignored: () -> _Schema<nil>
+  def prohibited: () -> _Schema<nil>
+end

data/sig/type.rbi

@@ -0,0 +1,89 @@
+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
+
+class StrongJSON::Type::Base<'a>
+  include Match
+
+  attr_reader type: base_type_name
+
+  def initialize: (base_type_name) -> any
+  def test: (any) -> bool
+  def coerce: (any, ?path: ::Array<Symbol>) -> 'a
+end
+
+class StrongJSON::Type::Optional<'t>
+  include Match
+
+  @type: _Schema<'t>
+
+  def initialize: (_Schema<'t>) -> any
+  def coerce: (any, ?path: ::Array<Symbol>) -> ('t | nil)
+end
+
+class StrongJSON::Type::Literal<'t>
+  include Match
+
+  attr_reader value: 't
+
+  def initialize: ('t) -> any
+  def coerce: (any, ?path: ::Array<Symbol>) -> 't
+end
+
+class StrongJSON::Type::Array<'t>
+  include Match
+
+  @type: _Schema<'t>
+
+  def initialize: (_Schema<'t>) -> any
+  def coerce: (any, ?path: ::Array<Symbol>) -> ::Array<'t>
+end
+
+class StrongJSON::Type::Object<'t>
+  include Match
+
+  @fields: Hash<Symbol, _Schema<'t>>
+
+  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>
+end
+
+class StrongJSON::Type::Enum<'t>
+  include Match
+
+  attr_reader types: ::Array<_Schema<any>>
+
+  def initialize: (::Array<_Schema<any>>) -> any
+  def coerce: (any, ?path: ::Array<Symbol>) -> 't
+end
+
+class StrongJSON::Type::Error
+  attr_reader path: ::Array<Symbol>
+  attr_reader type: ty
+  attr_reader value: any
+
+  def initialize: (path: ::Array<Symbol>, type: ty, value: any) -> any
+end
+
+class StrongJSON::Type::UnexpectedFieldError
+  attr_reader path: ::Array<Symbol>
+  attr_reader value: any
+
+  def initialize: (path: ::Array<Symbol>, value: any) -> any
+end
+
+class StrongJSON::Type::IllegalTypeError
+  attr_reader type: ty
+  def initialize: (type: ty) -> any
+end

data/strong_json.gemspec

@@ -17,8 +17,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.metadata = { "steep_types" => "sig" }
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "steep", "~> 0.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strong_json
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-11 00:00:00.000000000 Z
+date: 2018-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: steep
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 description: Type check JSON objects
 email:
 - matsumoto@soutaro.com
@@ -62,14 +76,19 @@ files:
 - ".gitignore"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- example/example.rb
+- example/example.rbi
 - lib/strong_json.rb
 - lib/strong_json/type.rb
 - lib/strong_json/types.rb
 - lib/strong_json/version.rb
+- sig/strong_json.rbi
+- sig/type.rbi
 - spec/array_spec.rb
 - spec/basetype_spec.rb
 - spec/case_subsumption_operator_spec.rb
@@ -83,7 +102,8 @@ files:
 homepage: https://github.com/soutaro/strong_json
 licenses:
 - MIT
-metadata: {}
+metadata:
+  steep_types: sig
 post_install_message: 
 rdoc_options: []
 require_paths: