strong_json 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4ebb2da5c4e3d195b5141cff335676d87868bf7
-  data.tar.gz: 8effc10c56e7208a846bbde39a144d2bb03bb91a
+  metadata.gz: ec2fc74653b07371d8619d7d830ede16d86e277f
+  data.tar.gz: 07b28f98c1d24ec5136bf77b86e66cb77fd2e103
 SHA512:
-  metadata.gz: 377ee5533793e2523b521721dfbb567e63f10077521905a19209b0e71201951fd7a2c9c2a2249fe10bac148df661a696d103ec252f3286cd8b1f672cb9b546a7
-  data.tar.gz: de56ca69657851d241233562be8ec5cc95296639e6991be9121fd49826282b8cc485dcd184c0e6c038236a2c7eac584d8bc029df0464a4528a79f36511cf656e
+  metadata.gz: f5a0c16aa825b4d59c7cccb177ad349117dd3a441546a88b7e30f851fed3cb30ed67d46fae6afd45def233082441e73e8495a7ed57f13747884131e3097313c9
+  data.tar.gz: debfe3a79493d228f22970b022aae0f2d73acc9800f0be93356a18d6cfa85f4de40302d89b7c7ce1e83844a326d589856233e4d88bcc0715775d51a15b3f64dd

data/README.md

@@ -3,7 +3,7 @@
 This library allows you to test the structure of JSON objects.
 
 This is similar to Strong Parameters, which is introduced by Rails 4, but expected to work with more complex structures.
-It may help you to understand what this is as: Strong Parameter is for simple structures, like HTML forms, and StrongJSON is for complex structures, like JSON objects posted to API.
+It may help you to understand what this is as: Strong Parameters is for simple structures, like HTML forms, and StrongJSON is for complex structures, like JSON objects posted to API.
 
 ## Installation
 
@@ -33,12 +33,11 @@ end
 json = s.order.coerce(JSON.parse(input))
 ```
 
-If the input JSON data is conformant with `order`'s structure, the `json` will be that value.
+If the input JSON data conforms to `order`'s structure, the `json` will be that value.
 
-If the input JSON contains attributes which is not white-listed in the definition, the fields will be droped.
+If the input JSON contains attributes which is not white-listed in the definition, it will raise an exception.
 
 If an attribute has a value which does not match with given type, the `coerce` method call will raise an exception `StrongJSON::Type::Error`.
-If the input JSON contains `prohibited` attributes, `id` of `item` in the example, it also will result in an exception.
 
 ## Catalogue of Types
 
@@ -46,7 +45,7 @@ If the input JSON contains `prohibited` attributes, `id` of `item` in the exampl
 
 * The value must be an object
 * Fields, `f1`, `f2`, and ..., must be present and its values must be of `type1`, `type2`, ..., respectively
-* Other fields will be ignored
+* Objects with other fields will be rejected
 
 ### array(type)
 
@@ -65,7 +64,7 @@ If the input JSON contains `prohibited` attributes, `id` of `item` in the exampl
 * `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
-* `prohibited` Any value will be rejected
+* `ignored` Any value will be ignored
 
 ### Shortcuts
 

data/lib/strong_json/type.rb

@@ -3,14 +3,16 @@ class StrongJSON
     NONE = ::Object.new
 
     class Base
+      attr_reader :type
+
       def initialize(type)
         @type = type
       end
 
-      def test(value, absent = false)
+      def test(value)
         case @type
-        when :prohibited
-          NONE.equal?(value)
+        when :ignored
+          true
         when :any
           true
         when :number
@@ -28,7 +30,8 @@ class StrongJSON
 
       def coerce(value, path: [])
         raise Error.new(value: value, type: self, path: path) unless test(value)
-        value
+        raise IllegalTypeError.new(type: self) if path == [] && @type == :ignored
+        @type != :ignored ? value : NONE
       end
 
       def to_s
@@ -86,14 +89,32 @@ class StrongJSON
 
         result = {}
 
-        @fields.each do |name, ty|
-          value = ty.coerce(object.has_key?(name) ? object[name] : NONE, path: path + [name])
-          result[name] = value if object.has_key?(name)
+        all_keys = (@fields.keys + object.keys).sort.uniq
+        all_keys.each do |key|
+          type = @fields.has_key?(key) ? @fields[key] : NONE
+          value = object.has_key?(key) ? object[key] : NONE
+
+          test_value_type(path + [key], type, value) do |v|
+            result[key] = v
+          end
         end
 
         result
       end
 
+      def test_value_type(path, type, value)
+        if NONE.equal?(type) && !NONE.equal?(value)
+          raise UnexpectedFieldError.new(path: path, value: value)
+        end
+
+        v = type.coerce(value, path: path)
+
+        return if NONE.equal?(v) || NONE.equal?(type)
+        return if type.is_a?(Optional) && v == nil
+
+        yield(v)
+      end
+
       def merge(fields)
         if fields.is_a?(Object)
           fields = Object.instance_variable_get("@fields")
@@ -119,6 +140,32 @@ class StrongJSON
       end
     end
 
+    class UnexpectedFieldError < StandardError
+      attr_reader :path, :value
+
+      def initialize(path: , value:)
+        @path = path
+        @value = value
+      end
+
+      def to_s
+        position = "#{path.join('.')}"
+        "Unexpected field of #{position} (#{value})"
+      end
+    end
+
+    class IllegalTypeError < StandardError
+      attr_reader :type
+
+      def initialize(type:)
+        @type = type
+      end
+
+      def to_s
+        "#{type} can not be put on toplevel"
+      end
+    end
+
     class Error < StandardError
       attr_reader :path, :type, :value
 
@@ -129,7 +176,7 @@ class StrongJSON
       end
 
       def to_s
-        position = " at #{path.join('.')}"
+        position = path.empty? ? "" : " at .#{path.join('.')}"
         "Expected type of value #{value}#{position} is #{type}"
       end
     end

data/lib/strong_json/types.rb

@@ -51,5 +51,9 @@ class StrongJSON
     def boolean?
       optional(boolean)
     end
+
+    def ignored
+      StrongJSON::Type::Base.new(:ignored)
+    end
   end
 end

data/lib/strong_json/version.rb

@@ -1,3 +1,3 @@
 class StrongJSON
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/spec/basetype_spec.rb

@@ -2,11 +2,11 @@ require "strong_json"
 
 describe StrongJSON::Type::Base do
   describe "#test" do
-    context ":prohibited" do
-      let (:type) { StrongJSON::Type::Base.new(:prohibited) }
+    context ":ignored" do
+      let (:type) { StrongJSON::Type::Base.new(:ignored) }
 
-      it "rejects number" do
-        expect(type.test(123)).to be_falsey
+      it "can not be placed on toplevel" do
+        expect { type.coerce(3, path: []) }.to raise_error(StrongJSON::Type::IllegalTypeError)
       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)
+      let :item, object(name: string, count: numeric, price: numeric, comment: ignored)
       let :checkout, object(items: array(item), change: optional(number))
     end
 

data/spec/object_spec.rb

@@ -9,23 +9,21 @@ describe StrongJSON::Type::Object do
       expect(type.coerce(a: 123, b: "test")).to eq(a: 123, b: "test")
     end
 
-    it "drops unspecified fields" do
+    it "rejects unspecified fields" do
       type = StrongJSON::Type::Object.new(a: StrongJSON::Type::Base.new(:numeric))
 
-      expect(type.coerce(a: 123, b: true)).to eq(a: 123)
+      expect { type.coerce(a:123, b:true) }.to raise_error(StrongJSON::Type::UnexpectedFieldError)
     end
 
-    describe "prohibited" do
-      it "rejects field with any value" do
-        type = StrongJSON::Type::Object.new(a: StrongJSON::Type::Base.new(:prohibited))
-
-        expect{ type.coerce(a: 123, b: true) }.to raise_error(StrongJSON::Type::Error)
+    describe "ignored" do
+      it "ignores field with any value" do
+        type = StrongJSON::Type::Object.new(a: StrongJSON::Type::Base.new(:numeric), b: StrongJSON::Type::Base.new(:ignored))
+        expect(type.coerce(a: 123, b: true)).to eq(a: 123)
       end
 
       it "accepts if it does not contains the field" do
-        type = StrongJSON::Type::Object.new(a: StrongJSON::Type::Base.new(:prohibited))
-
-        expect(type.coerce(b: true)).to eq({})
+        type = StrongJSON::Type::Object.new(a: StrongJSON::Type::Base.new(:numeric), b: StrongJSON::Type::Base.new(:ignored))
+        expect(type.coerce(a: 123)).to eq(a: 123)
       end
     end
 
@@ -38,7 +36,7 @@ describe StrongJSON::Type::Object do
     it "accepts missing field if optional" do
       type = StrongJSON::Type::Object.new(a: StrongJSON::Type::Optional.new(StrongJSON::Type::Base.new(:numeric)))
 
-      expect(type.coerce(b: "test")).to eq({})
+      expect(type.coerce({})).to eq({})
     end
   end
 
@@ -63,8 +61,7 @@ describe StrongJSON::Type::Object do
 
     it "return object which ignores given fields but preserve others" do
       ty2 = type.except(:a)
-
-      expect(ty2.coerce(a: 123, b: "test")).to eq({ b: "test" })
+      expect(ty2.coerce(b: "test")).to eq({ b: "test" })
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strong_json
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-16 00:00:00.000000000 Z
+date: 2015-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler