strong_json 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a009e9385e3e0d6dceed251b6951e533d8d9cae
-  data.tar.gz: 26c8e89826ebe9b88b325c647c662d7b89013ddf
+  metadata.gz: 3740cb9d6923fabe6e9a14b191771d5dad7b5328
+  data.tar.gz: d719d0f91add645572ed65a1e89167f357037621
 SHA512:
-  metadata.gz: d597908375f4112ee71f931f60a4c489ead56ae2c56c31fac8f185375aad38539ded3b846e8ce4207d32641f4641cccb244dc28ee8dcf20487f0dfb12108de5b
-  data.tar.gz: 643ca3880954ba6fd3f5ac9654313d604744c50f79142af703364281d1aab35d406b3610fced4b1ef0a79fc5a711d95fb03887c22cb7f77294d687b9d6898c79
+  metadata.gz: ee65118af560df40ffa22a18d3b30fe376eddb3282a999027df49e8d59d71a899dd49ae3fcdbc90fa4a0c1a239b14eee5e014aae161297e6c2a516f50419dae1
+  data.tar.gz: dc7f9eae7a70b1d8967ead36cef902275908db9a7d2f83f204924a95d5c74cb6e4909c34061eb17f49782766d64989e2d6e811f211cc840a816528d5c288d02d

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/README.md

@@ -30,7 +30,8 @@ s = StrongJSON.new do
   let :order, object(customer: customer, items: array(item))
 end
 
-json = s.order.coerce(JSON.parse(input))
+json = s.order.coerce(JSON.parse(input), symbolize_names: true)
+s.order =~ JSON.parse(input, symbolize_names: true)
 ```
 
 If the input JSON data conforms to `order`'s structure, the `json` will be that value.
@@ -57,6 +58,11 @@ If an attribute has a value which does not match with given type, the `coerce` m
 * The value can be `nil` (or not contained in an object)
 * If an value exists, it must be of given `type`
 
+### enum(type1, type2, ...)
+
+* The value can be one of the given types
+* First successfully coerced value will return
+
 ### Base types
 
 * `number` The value must be an instance of `Numeric`
@@ -65,6 +71,11 @@ If an attribute has a value which does not match with given type, the `coerce` m
 * `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
+
+* `literal(lit)` The value must `=== lit`
 
 ### Shortcuts
 
@@ -74,6 +85,8 @@ There are some alias for `optional(base)`, where base is base types, as the foll
 * `string?`
 * `boolean?`
 * `numeric?`
+* `symbol?`
+* `literal?(lit)`
 
 Shorthands for `optional(array(ty))` and `optional(object(fields))` are also defined as the following:
 

data/lib/strong_json/type.rb

@@ -2,7 +2,18 @@ class StrongJSON
   module Type
     NONE = ::Object.new
 
+    module Match
+      def =~(value)
+        coerce(value)
+        true
+      rescue
+        false
+      end
+    end
+
     class Base
+      include Match
+
       attr_reader :type
 
       def initialize(type)
@@ -23,6 +34,8 @@ class StrongJSON
           value == true || value == false
         when :numeric
           value.is_a?(Numeric) || value.is_a?(String) && /\A[\-\+]?[\d.]+\Z/ =~ value
+        when :symbol
+          value.is_a?(String) || value.is_a?(Symbol)
         else
           false
         end
@@ -31,7 +44,15 @@ class StrongJSON
       def coerce(value, path: [])
         raise Error.new(value: value, type: self, path: path) unless test(value)
         raise IllegalTypeError.new(type: self) if path == [] && @type == :ignored
-        @type != :ignored ? value : NONE
+
+        case type
+        when :ignored
+          NONE
+        when :symbol
+          value.to_sym
+        else
+          value
+        end
       end
 
       def to_s
@@ -40,6 +61,8 @@ class StrongJSON
     end
 
     class Optional
+      include Match
+
       def initialize(type)
         @type = type
       end
@@ -57,7 +80,28 @@ class StrongJSON
       end
     end
 
+    class Literal
+      include Match
+
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def to_s
+        "literal(#{@value})"
+      end
+
+      def coerce(value, path: [])
+        raise Error.new(path: path, type: self, value: value) unless self.value == value
+        value
+      end
+    end
+
     class Array
+      include Match
+
       def initialize(type)
         @type = type
       end
@@ -78,6 +122,8 @@ class StrongJSON
     end
 
     class Object
+      include Match
+
       def initialize(fields)
         @fields = fields
       end
@@ -140,6 +186,30 @@ class StrongJSON
       end
     end
 
+    class Enum
+      include Match
+
+      attr_reader :types
+
+      def initialize(types)
+        @types = types
+      end
+
+      def to_s
+        "enum(#{types.map(&:to_s).join(", ")})"
+      end
+
+      def coerce(value, path: [])
+        type = types.find {|ty| ty =~ value }
+
+        if type
+          type.coerce(value, path: path)
+        else
+          raise Error.new(path: path, type: self, value: value)
+        end
+      end
+    end
+
     class UnexpectedFieldError < StandardError
       attr_reader :path, :value
 

data/lib/strong_json/types.rb

@@ -36,6 +36,18 @@ class StrongJSON
       StrongJSON::Type::Base.new(:prohibited)
     end
 
+    def symbol
+      StrongJSON::Type::Base.new(:symbol)
+    end
+
+    def literal(value)
+      StrongJSON::Type::Literal.new(value)
+    end
+
+    def enum(*types)
+      StrongJSON::Type::Enum.new(types)
+    end
+
     def string?
       optional(string)
     end
@@ -52,6 +64,10 @@ class StrongJSON
       optional(boolean)
     end
 
+    def symbol?
+      optional(symbol)
+    end
+
     def ignored
       StrongJSON::Type::Base.new(:ignored)
     end
@@ -63,5 +79,9 @@ class StrongJSON
     def object?(fields)
       optional(object(fields))
     end
+
+    def literal?(value)
+      optional(literal(value))
+    end
   end
 end

data/lib/strong_json/version.rb

@@ -1,3 +1,3 @@
 class StrongJSON
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/array_spec.rb

@@ -35,4 +35,16 @@ describe StrongJSON::Type::Array, "#coerce" do
 
     expect { type.coerce(nil) }.to raise_error(StrongJSON::Type::Error)
   end
+
+  describe "=~" do
+    it "returns true for array" do
+      type = StrongJSON::Type::Array.new(StrongJSON::Type::Base.new(:number))
+      expect(type =~ []).to be_truthy
+    end
+
+    it "returns false for number" do
+      type = StrongJSON::Type::Array.new(StrongJSON::Type::Base.new(:number))
+      expect(type =~ 3.0).to be_falsey
+    end
+  end
 end

data/spec/basetype_spec.rb

@@ -24,6 +24,20 @@ describe StrongJSON::Type::Base do
       it "rejects string" do
         expect(type.test("string")).to be_falsey
       end
+
+      describe "=~" do
+        it "returns true for integer" do
+          expect(type =~ 3).to be_truthy
+        end
+
+        it "returns true for float" do
+          expect(type =~ 3.0).to be_truthy
+        end
+
+        it "returns false for string" do
+          expect(type =~ "foo").to be_falsey
+        end
+      end
     end
 
     context ":string" do
@@ -32,6 +46,16 @@ describe StrongJSON::Type::Base do
       it "accepts string" do
         expect(type.test("string")).to be_truthy
       end
+
+      describe "=~" do
+        it "returns true for string" do
+          expect(type =~ "3").to be_truthy
+        end
+
+        it "returns false for number" do
+          expect(type =~ 3.0).to be_falsey
+        end
+      end
     end
 
     context ":any" do
@@ -44,6 +68,12 @@ describe StrongJSON::Type::Base do
       it "accepts number" do
         expect(type.test(2.71828)).to be_truthy
       end
+
+      describe "=~" do
+        it "returns true for string" do
+          expect(type =~ "3").to be_truthy
+        end
+      end
     end
 
     context ":boolean" do
@@ -60,6 +90,16 @@ describe StrongJSON::Type::Base do
       it "rejects nil" do
         expect(type.test(nil)).to be_falsey
       end
+
+      describe "=~" do
+        it "returns true for boolean" do
+          expect(type =~ true).to be_truthy
+        end
+
+        it "returns false for nil" do
+          expect(type =~ nil).to be_falsey
+        end
+      end
     end
 
     context ":numeric" do
@@ -92,6 +132,50 @@ describe StrongJSON::Type::Base do
       it "rejects boolean" do
         expect(type.test(true)).to be_falsey
       end
+
+      describe "=~" do
+        it "returns true for numeric string" do
+          expect(type =~ "3").to be_truthy
+        end
+
+        it "returns false for boolean" do
+          expect(type =~ false).to be_falsey
+        end
+      end
+    end
+
+    context ":symbol" do
+      let (:type) { StrongJSON::Type::Base.new(:symbol) }
+
+      describe "#test" do
+        it "returns true for string" do
+          expect(type.test("foo")).to be_truthy
+        end
+
+        it "returns true for symbol" do
+          expect(type.test(:foo)).to be_truthy
+        end
+
+        it "returns false for boolean" do
+          expect(type.test(false)).to be_falsey
+        end
+      end
+
+      describe "#=~" do
+        it "returns true for string" do
+          expect(type =~ 'foo').to be_truthy
+        end
+
+        it "returns false for number" do
+          expect(type =~ 3).to be_falsey
+        end
+      end
+
+      describe "#coerce" do
+        it "returns symbol" do
+          expect(type.coerce("foo")).to eq(:foo)
+        end
+      end
     end
   end
 end

data/spec/enum_spec.rb

@@ -0,0 +1,45 @@
+require "strong_json"
+
+describe StrongJSON::Type::Enum do
+  describe "=~" do
+    let (:type) {
+      StrongJSON::Type::Enum.new([StrongJSON::Type::Literal.new(3),
+                                  StrongJSON::Type::Literal.new(4)])
+    }
+
+    it "returns true for 3" do
+      expect(type =~ 3).to be_truthy
+    end
+
+    it "returns true for 4" do
+      expect(type =~ 4).to be_truthy
+    end
+
+    it "returns false for 5" do
+      expect(type =~ 5).to be_falsey
+    end
+  end
+
+  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))
+                                 ])
+    }
+
+    it "returns object with string value" do
+      expect(type.coerce({id: "id1", value: "foo" })).to eq({ id: "id1", value: "foo" })
+    end
+
+    it "returns object with symbol value" do
+      expect(type.coerce({id: "id2", value: "foo" })).to eq({ id: "id2", value: :foo })
+    end
+
+    it "raises error" do
+      expect { type.coerce(3.14) }.to raise_error(StrongJSON::Type::Error)
+    end
+  end
+end

data/spec/json_spec.rb

@@ -4,9 +4,9 @@ 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))
+      let :checkout, object(items: array(item), change: optional(number), type: enum(literal(1), symbol))
     end
 
-    expect(s.checkout.coerce(items: [ { name: "test", count: 1, price: "2.33", comment: "dummy" } ])).to eq(items: [ { name: "test", count: 1, price: "2.33" }])
+    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)
   end
 end

data/spec/literal_spec.rb

@@ -0,0 +1,15 @@
+require "strong_json"
+
+describe StrongJSON::Type::Literal do
+  describe "=~" do
+    let (:type) { StrongJSON::Type::Literal.new(3) }
+
+    it "returns true if == holds" do
+      expect(type =~ 3).to be_truthy
+    end
+
+    it "returns false if == doesn't hold" do
+      expect(type =~ 4).to be_falsey
+    end
+  end
+end

data/spec/object_spec.rb

@@ -75,4 +75,16 @@ describe StrongJSON::Type::Object do
       expect(ty2.coerce(b: "test")).to eq({ b: "test" })
     end
   end
+
+  describe "=~" do
+    let (:type) { StrongJSON::Type::Object.new(a: StrongJSON::Type::Base.new(:numeric), b: StrongJSON::Type::Base.new(:string)) }
+
+    it "returns true for valid object" do
+      expect(type =~ { a: 3, b: "foo" }).to be_truthy
+    end
+
+    it "returns false for invalid number" do
+      expect(type =~ {}).to be_falsey
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strong_json
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-27 00:00:00.000000000 Z
+date: 2016-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -60,6 +60,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
@@ -71,8 +72,10 @@ files:
 - lib/strong_json/version.rb
 - spec/array_spec.rb
 - spec/basetype_spec.rb
+- spec/enum_spec.rb
 - spec/error_spec.rb
 - spec/json_spec.rb
+- spec/literal_spec.rb
 - spec/object_spec.rb
 - spec/optional_spec.rb
 - strong_json.gemspec
@@ -96,14 +99,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Type check JSON objects
 test_files:
 - spec/array_spec.rb
 - spec/basetype_spec.rb
+- spec/enum_spec.rb
 - spec/error_spec.rb
 - spec/json_spec.rb
+- spec/literal_spec.rb
 - spec/object_spec.rb
 - spec/optional_spec.rb