tjson 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5324e4ee4f01304e7330ed40c78c55eadfa8419e
-  data.tar.gz: 957686c2c7a4f589912a04e734b0aef2572621c7
+  metadata.gz: e9c267b98ee23f52126fd4ee7fcea4e2c83d904f
+  data.tar.gz: 7d1844da5a4491a0864b9ffbcded27899104bb03
 SHA512:
-  metadata.gz: 6f8ef3abc0f62a1f70ad46c285866c4d5847ec69c8112e0005d73564082c34d3d6c3b3c75f8b45bcaac8f9bb39eb14e23e281b88c9e46346abb6a54b5a2c3bf6
-  data.tar.gz: e020ee6c927f8ac48b17e00b09905ff7951ea50a5cfc65d1117d5d143b0f1ead6d291a9f86037cb1cae4d9a77b936b930d3796d553761f6cfa24c14f5009a59c
+  metadata.gz: 52fc6e24de955cfbc76ad5933b8613c7550455e87362b1615d0dd53b86f1e002d543de083d881ddd8f730d13f0c3906c82200e9d0ef16f880bd87030107c59ac
+  data.tar.gz: 317419a6d6624ba43e117fbc13b109e8b7ba678588fcaa41493b52e07799c89c3272dd9356717034937d1dbb0c52bb343523d19a9bb432d9a67b636b68bd83d5

data/.travis.yml

@@ -4,16 +4,22 @@ before_install: gem install bundler
 
 bundler_args: --without development doc
 
+script: bundle exec rake ci
+
 rvm:
+  - jruby-9.1.5.0
   - 2.0
   - 2.1
   - 2.2
   - 2.3.1
   - 2.4.1
-  - jruby-9.1.5.0
 
 matrix:
   fast_finish: true
+  include:
+  # Only run RuboCop on the latest Ruby
+  - env: SUITE="rubocop"
+    rvm: 2.4.1
 
 branches:
   only:

data/CHANGES.md

@@ -1,3 +1,7 @@
+## 0.5.0 (2017-04-22)
+
+* Use "b" for boolean (reassigning binary data to "d")
+
 ## 0.4.0 (2017-04-16)
 
 * Add support for Boolean Value and Set types

data/README.md

@@ -1,8 +1,24 @@
 # TJSON for Ruby [![Gem Version][gem-image]][gem-link] [![Build Status][build-image]][build-link] [![Code Climate][codeclimate-image]][codeclimate-link] [![MIT licensed][license-image]][license-link]
 
-A Ruby implementation of TJSON: Tagged JSON with Rich Types.
+A Ruby implementation of [TJSON]: Tagged JSON with Rich Types.
 
-https://www.tjson.org
+[TJSON]: https://www.tjson.org
+
+```json
+{
+  "array-example:A<O>": [
+    {
+      "string-example:s": "foobar",
+      "binary-data-example:d": "QklOQVJZ",
+      "float-example:f": 0.42,
+      "int-example:i": "42",
+      "timestamp-example:t": "2016-11-06T22:27:34Z",
+      "boolean-example:b": true
+    }
+  ],
+  "set-example:S<i>": [1, 2, 3]
+}
+```
 
 [gem-image]: https://badge.fury.io/rb/tjson.svg
 [gem-link]: https://rubygems.org/gems/tjson
@@ -13,6 +29,30 @@ https://www.tjson.org
 [license-image]: https://img.shields.io/badge/license-MIT-blue.svg
 [license-link]: https://github.com/tjson/tjson-ruby/blob/master/LICENSE.txt
 
+## Help and Discussion
+
+Have questions? Want to suggest a feature or change?
+
+* [TJSON Gitter]: web-based chat
+* [TJSON Google Group]: join via web or email ([tjson+subscribe@googlegroups.com])
+
+[TJSON Gitter]: https://gitter.im/tjson/Lobby
+[TJSON Google Group]: https://groups.google.com/forum/#!forum/tjson
+[tjson+subscribe@googlegroups.com]: mailto:tjson+subscribe@googlegroups.com
+
+## Requirements
+
+This library is tested against the following Ruby versions:
+
+- 2.0
+- 2.1
+- 2.2
+- 2.3
+- 2.4
+- jruby 9.1
+
+Other Ruby versions may work, but are not officially supported.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -29,9 +69,9 @@ Or install it yourself as:
 
     $ gem install tjson
 
-## Usage
+## API
 
-### Parsing
+### TJSON.parse
 
 To parse a TJSON document, use the `TJSON.parse` method:
 
@@ -40,43 +80,55 @@ To parse a TJSON document, use the `TJSON.parse` method:
 => {"foo"=>"bar"}
 ```
 
-The following describes how TJSON types map onto Ruby types during parsing:
-
- * **Unicode Strings**: parsed as Ruby `String` with `Encoding::UTF_8`
- * **Binary Data**: parsed as Ruby `String` with `Encoding::ASCII_8BIT` (a.k.a. `Encoding::BINARY`)
- * **Integers**: parsed as Ruby `Integer` (Fixnum or Bignum)
- * **Floats** (i.e. JSON number literals): parsed as Ruby `Float`
- * **Timestamps**: parsed as Ruby `Time`
- * **Arrays**: parsed as Ruby `Array`
- * **Objects**: parsed as `TJSON::Object` (a subclass of `::Hash`)
-
-### Generating
+### TJSON.generate
 
 To generate TJSON from Ruby objects, use the `TJSON.generate` method:
 
 ```ruby
 puts TJSON.generate({"foo" => "bar"})
-{"foo:s:"bar"}
+# {"foo:s:"bar"}
 ```
 
 For better formatting, use the `TJSON.pretty_generate` method:
 
 ```ruby
-puts TJSON.pretty_generate({"array-example" => [{"string-example" => "foobar", "binary-example" => "BINARY".encode(Encoding::BINARY), "float-example" => 0.42, "int-example" => 42, "timestamp-example" => Time.now}]})
-{
-  "array-example:A<O>": [
-    {
-      "string-example:s": "foobar",
-      "binary-example:b64": "QklOQVJZ",
-      "float-example:f": 0.42,
-      "int-example:i": "42",
-      "timestamp-example:t": "2016-11-06T22:27:34Z"
-    }
-  ]
-}
+puts TJSON.pretty_generate({"array-example" => [{"string-example" => "foobar", "binary-example" => "BINARY".b, "float-example" => 0.42, "int-example" => 42, "timestamp-example" => Time.now}]})
+# {
+#   "array-example:A<O>": [
+#     {
+#       "string-example:s": "foobar",
+#       "binary-example:d": "QklOQVJZ",
+#       "float-example:f": 0.42,
+#       "int-example:i": "42",
+#       "timestamp-example:t": "2016-11-06T22:27:34Z"
+#     }
+#   ]
+# }
 ```
 
+## Type Conversions
+
+The table below shows how TJSON tags map to Ruby types:
+
+| Tag | Ruby Type                                                        |
+|-----|------------------------------------------------------------------|
+| `b` | `true` or `false`                                                |
+| `d` | `String` with `Encoding::ASCII_8BIT` (a.k.a. `Encoding::BINARY`) |
+| `f` | `Float`                                                          |
+| `i` | `Integer` (`Fixnum` or `Bignum` on Ruby <2.4 )                   |
+| `u` | `Integer` (`Fixnum` or `Bignum` on Ruby <2.4 )                   |
+| `s` | `String` with `Encoding::UTF_8`                                  |
+| `t` | `Time`                                                           |
+| `A` | `Array`                                                          |
+| `O` | `TJSON::Object` (a subclass of `::Hash`)                         |
+| `S` | `Set`                                                            |
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/tjson/tjson-ruby
 
+## License
+
+Copyright (c) 2017 Tony Arcieri. Distributed under the MIT License. See
+[LICENSE.txt](https://github.com/tjson/tjson-ruby/blob/master/LICENSE.txt)
+for further details.

data/Rakefile

@@ -9,3 +9,8 @@ require "rubocop/rake_task"
 RuboCop::RakeTask.new
 
 task default: %w[spec rubocop]
+
+case ENV["SUITE"]
+when "rubocop" then task ci: %w[rubocop]
+else task ci: %w[spec]
+end

data/lib/tjson.rb

@@ -12,6 +12,16 @@ require "base64"
 require "tjson/datatype"
 require "tjson/object"
 
+require "tjson/datatype/array"
+require "tjson/datatype/boolean"
+require "tjson/datatype/binary"
+require "tjson/datatype/float"
+require "tjson/datatype/integer"
+require "tjson/datatype/object"
+require "tjson/datatype/set"
+require "tjson/datatype/string"
+require "tjson/datatype/timestamp"
+
 # Tagged JSON with Rich Types
 module TJSON
   # Base class of all TJSON errors
@@ -32,6 +42,31 @@ module TJSON
   # Maximum allowed nesting (TODO: use TJSON-specified maximum)
   MAX_NESTING = 100
 
+  # Reopen the DataType class (defined in tjson/datatype.rb)
+  class DataType
+    # Table of tag identifiers supported by TJSON
+    TAGS = {
+      # Object (non-scalar with self-describing types)
+      "O" => TJSON::DataType::Object.new(nil).freeze,
+
+      # Non-scalars
+      "A" => TJSON::DataType::Array,
+      "S" => TJSON::DataType::Set,
+
+      # Scalars
+      "b"   => TJSON::DataType::Boolean.new.freeze,
+      "d"   => TJSON::DataType::Binary64.new.freeze,
+      "d16" => TJSON::DataType::Binary16.new.freeze,
+      "d32" => TJSON::DataType::Binary32.new.freeze,
+      "d64" => TJSON::DataType::Binary64.new.freeze,
+      "f"   => TJSON::DataType::Float.new.freeze,
+      "i"   => TJSON::DataType::SignedInt.new.freeze,
+      "s"   => TJSON::DataType::String.new.freeze,
+      "t"   => TJSON::DataType::Timestamp.new.freeze,
+      "u"   => TJSON::DataType::UnsignedInt.new.freeze
+    }.freeze
+  end
+
   # Parse the given UTF-8 string as TJSON
   #
   # @param string [String] TJSON string to be parsed
@@ -80,7 +115,7 @@ module TJSON
   # @return [String] serialized TJSON
   def self.generate(obj)
     raise TypeError, "toplevel type must be a Hash" unless obj.is_a?(Hash)
-    JSON.generate(TJSON::DataType.generate(obj))
+    JSON.generate(TJSON::DataType.encode(obj))
   end
 
   # Generate TJSON from a Ruby Hash (TJSON only allows objects as toplevel values)
@@ -89,6 +124,6 @@ module TJSON
   # @return [String] serialized TJSON
   def self.pretty_generate(obj)
     raise TypeError, "toplevel type must be a Hash" unless obj.is_a?(Hash)
-    JSON.pretty_generate(TJSON::DataType.generate(obj))
+    JSON.pretty_generate(TJSON::DataType.encode(obj))
   end
 end

data/lib/tjson/datatype.rb

@@ -31,38 +31,34 @@ module TJSON
       when Hash               then self["O"]
       when ::Array            then TJSON::DataType::Array.identify_type(obj)
       when ::Set              then TJSON::DataType::Set.identify_type(obj)
-      when ::String, Symbol   then obj.encoding == Encoding::BINARY ? self["b"] : self["s"]
+      when ::String, Symbol   then obj.encoding == Encoding::BINARY ? self["d"] : self["s"]
       when ::Integer          then self["i"]
       when ::Float            then self["f"]
       when ::TrueClass        then self["v"]
-      when ::FalseClass       then self["v"]
+      when ::FalseClass       then self["d"]
       when ::Time, ::DateTime then self["t"]
       else raise TypeError, "don't know how to serialize #{obj.class} as TJSON"
       end
     end
 
-    def self.generate(obj)
-      identify_type(obj).generate(obj)
+    def self.encode(obj)
+      identify_type(obj).encode(obj)
     end
 
     def tag
       raise NotImplementError, "no #tag defined for #{self.class}"
     end
 
-    def convert(_value)
-      raise NotImplementedError, "#{self.class} does not implement #convert"
+    def decode(_value)
+      raise NotImplementedError, "#{self.class} does not implement #decode"
     end
 
-    def generate(_value)
+    def encode(_value)
       raise NotImplementedError, "#{self.class} does not implement #genreate"
     end
 
     # Scalar types
     class Scalar < TJSON::DataType
-      def scalar?
-        true
-      end
-
       def inspect
         "#<#{self.class}>"
       end
@@ -80,48 +76,9 @@ module TJSON
         "#<#{self.class}<#{@inner_type.inspect}>>"
       end
 
-      def scalar?
-        false
-      end
-
       def ==(other)
         self.class == other.class && inner_type == other.inner_type
       end
     end
-
-    # Numbers
-    class Number < Scalar; end
   end
 end
-
-require "tjson/datatype/array"
-require "tjson/datatype/binary"
-require "tjson/datatype/float"
-require "tjson/datatype/integer"
-require "tjson/datatype/set"
-require "tjson/datatype/string"
-require "tjson/datatype/timestamp"
-require "tjson/datatype/object"
-require "tjson/datatype/value"
-
-# TJSON does not presently support user-extensible types
-TJSON::DataType::TAGS = {
-  # Object (non-scalar with self-describing types)
-  "O" => TJSON::DataType::Object.new(nil).freeze,
-
-  # Non-scalars
-  "A" => TJSON::DataType::Array,
-  "S" => TJSON::DataType::Set,
-
-  # Scalars
-  "b"   => TJSON::DataType::Binary64.new.freeze,
-  "b16" => TJSON::DataType::Binary16.new.freeze,
-  "b32" => TJSON::DataType::Binary32.new.freeze,
-  "b64" => TJSON::DataType::Binary64.new.freeze,
-  "f"   => TJSON::DataType::Float.new.freeze,
-  "i"   => TJSON::DataType::SignedInt.new.freeze,
-  "s"   => TJSON::DataType::String.new.freeze,
-  "t"   => TJSON::DataType::Timestamp.new.freeze,
-  "u"   => TJSON::DataType::UnsignedInt.new.freeze,
-  "v"   => TJSON::DataType::Value.new.freeze
-}.freeze

data/lib/tjson/datatype/array.rb

@@ -21,16 +21,16 @@ module TJSON
         "A<#{@inner_type.tag}>"
       end
 
-      def convert(array)
+      def decode(array)
         raise TJSON::TypeError, "expected Array, got #{array.class}" unless array.is_a?(::Array)
 
-        return array.map! { |o| @inner_type.convert(o) } if @inner_type
+        return array.map! { |o| @inner_type.decode(o) } if @inner_type
         return array if array.empty?
         raise TJSON::ParseError, "no inner type specified for non-empty array: #{array.inspect}"
       end
 
-      def generate(array)
-        array.map { |o| TJSON::DataType.generate(o) }
+      def encode(array)
+        array.map { |o| TJSON::DataType.encode(o) }
       end
     end
   end

data/lib/tjson/datatype/binary.rb

@@ -2,16 +2,13 @@
 
 module TJSON
   class DataType
-    # Binary Data
-    class Binary < Scalar; end
-
     # Base16-serialized binary data
-    class Binary16 < Binary
+    class Binary16 < Scalar
       def tag
-        "b16"
+        "d16"
       end
 
-      def convert(str)
+      def decode(str)
         raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
         raise TJSON::ParseError, "base16 must be lower case: #{str.inspect}" if str =~ /[A-F]/
         raise TJSON::ParseError, "invalid base16: #{str.inspect}" unless str =~ /\A[a-f0-9]*\z/
@@ -19,18 +16,18 @@ module TJSON
         [str].pack("H*")
       end
 
-      def generate(binary)
+      def encode(binary)
         binary.unpack("H*").first
       end
     end
 
     # Base32-serialized binary data
-    class Binary32 < Binary
+    class Binary32 < Scalar
       def tag
-        "b32"
+        "d32"
       end
 
-      def convert(str)
+      def decode(str)
         raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
         raise TJSON::ParseError, "base32 must be lower case: #{str.inspect}" if str =~ /[A-Z]/
         raise TJSON::ParseError, "padding disallowed: #{str.inspect}" if str.include?("=")
@@ -39,18 +36,18 @@ module TJSON
         ::Base32.decode(str.upcase).force_encoding(Encoding::BINARY)
       end
 
-      def generate(binary)
+      def encode(binary)
         Base32.encode(binary).downcase.delete("=")
       end
     end
 
     # Base64-serialized binary data
-    class Binary64 < Binary
+    class Binary64 < Scalar
       def tag
-        "b64"
+        "d64"
       end
 
-      def convert(str)
+      def decode(str)
         raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
         raise TJSON::ParseError, "base64url only: #{str.inspect}" if str =~ %r{\+|\/}
         raise TJSON::ParseError, "padding disallowed: #{str.inspect}" if str.include?("=")
@@ -62,7 +59,7 @@ module TJSON
         ::Base64.urlsafe_decode64(str)
       end
 
-      def generate(binary)
+      def encode(binary)
         Base64.urlsafe_encode64(binary).delete("=")
       end
     end

data/lib/tjson/datatype/{value.rb → boolean.rb}

@@ -3,18 +3,18 @@
 module TJSON
   class DataType
     # Boolean Value
-    class Value < Scalar
+    class Boolean < Scalar
       def tag
-        "v"
+        "b"
       end
 
-      def convert(value)
+      def decode(value)
         raise TJSON::TypeError, "'null' is expressly disallowed in TJSON" if value.nil?
         raise TJSON::TypeError, "not a boolean value: #{value.inspect}" unless [true, false].include?(value)
         value
       end
 
-      def generate(value)
+      def encode(value)
         value
       end
     end

data/lib/tjson/datatype/float.rb

@@ -3,17 +3,17 @@
 module TJSON
   class DataType
     # Floating point type
-    class Float < Number
+    class Float < Scalar
       def tag
         "f"
       end
 
-      def convert(float)
+      def decode(float)
         raise TJSON::TypeError, "not a floating point value: #{float.inspect}" unless float.is_a?(::Numeric)
         float.to_f
       end
 
-      def generate(float)
+      def encode(float)
         float.to_f
       end
     end

data/lib/tjson/datatype/integer.rb

@@ -4,7 +4,7 @@ module TJSON
   class DataType
     # Base class of integer types
     class Integer < Scalar
-      def generate(int)
+      def encode(int)
         # Integers are serialized as strings to sidestep the limits of some JSON parsers
         int.to_s
       end
@@ -16,7 +16,7 @@ module TJSON
         "i"
       end
 
-      def convert(str)
+      def decode(str)
         raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
         raise TJSON::ParseError, "invalid integer: #{str.inspect}" unless str =~ /\A\-?(0|[1-9][0-9]*)\z/
 
@@ -34,7 +34,7 @@ module TJSON
         "u"
       end
 
-      def convert(str)
+      def decode(str)
         raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
         raise TJSON::ParseError, "invalid integer: #{str.inspect}" unless str =~ /\A(0|[1-9][0-9]*)\z/
 

data/lib/tjson/datatype/object.rb

@@ -8,18 +8,18 @@ module TJSON
         "O"
       end
 
-      def convert(obj)
+      def decode(obj)
         raise TJSON::TypeError, "expected TJSON::Object, got #{obj.class}" unless obj.is_a?(TJSON::Object)
 
         # Objects handle their own member conversions
         obj
       end
 
-      def generate(obj)
+      def encode(obj)
         members = obj.map do |k, v|
           raise TypeError, "expected String for key, got #{k.class}" unless k.is_a?(::String) || k.is_a?(Symbol)
           type = TJSON::DataType.identify_type(v)
-          ["#{k}:#{type.tag}", TJSON::DataType.generate(v)]
+          ["#{k}:#{type.tag}", TJSON::DataType.encode(v)]
         end
 
         Hash[members]

data/lib/tjson/datatype/set.rb

@@ -21,11 +21,11 @@ module TJSON
         "S<#{@inner_type.tag}>"
       end
 
-      def convert(array)
+      def decode(array)
         raise TJSON::TypeError, "expected Array, got #{array.class}" unless array.is_a?(::Array)
 
         if @inner_type
-          result = ::Set.new(array.map { |o| @inner_type.convert(o) })
+          result = ::Set.new(array.map { |o| @inner_type.decode(o) })
           raise TJSON::ParseError, "set contains duplicate items" if result.size < array.size
           return result
         end
@@ -34,7 +34,7 @@ module TJSON
         raise TJSON::ParseError, "no inner type specified for non-empty set: #{array.inspect}"
       end
 
-      def generate(set)
+      def encode(set)
         set.map { |o| TJSON::DataType.generate(o) }
       end
     end

data/lib/tjson/datatype/string.rb

@@ -8,13 +8,13 @@ module TJSON
         "s"
       end
 
-      def convert(str)
+      def decode(str)
         raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
         raise TJSON::EncodingError, "expected UTF-8, got #{str.encoding.inspect}" unless str.encoding == Encoding::UTF_8
         str
       end
 
-      def generate(obj)
+      def encode(obj)
         obj.to_s
       end
     end

data/lib/tjson/datatype/timestamp.rb

@@ -11,14 +11,14 @@ module TJSON
         "t"
       end
 
-      def convert(str)
+      def decode(str)
         raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
         raise TJSON::ParseError, "invalid timestamp: #{str.inspect}" unless str =~ TIMESTAMP_REGEX
 
         ::Time.iso8601(str)
       end
 
-      def generate(timestamp)
+      def encode(timestamp)
         timestamp.to_time.utc.iso8601
       end
     end

data/lib/tjson/object.rb

@@ -11,7 +11,7 @@ module TJSON
       raise DuplicateNameError, "duplicate member name: #{result[:name].inspect}" if key?(result[:name])
 
       type = TJSON::DataType.parse(result[:tag])
-      super(result[:name], type.convert(value))
+      super(result[:name], type.decode(value))
     end
   end
 end

data/lib/tjson/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TJSON
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: tjson
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-17 00:00:00.000000000 Z
+date: 2017-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base32
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.13'
 description: A JSON-compatible serialization format with rich type annotations
@@ -45,12 +45,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rakeTasks
-- .rspec
-- .rubocop.yml
-- .ruby-version
-- .travis.yml
+- ".gitignore"
+- ".rakeTasks"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - Guardfile
@@ -61,13 +61,13 @@ files:
 - lib/tjson/datatype.rb
 - lib/tjson/datatype/array.rb
 - lib/tjson/datatype/binary.rb
+- lib/tjson/datatype/boolean.rb
 - lib/tjson/datatype/float.rb
 - lib/tjson/datatype/integer.rb
 - lib/tjson/datatype/object.rb
 - lib/tjson/datatype/set.rb
 - lib/tjson/datatype/string.rb
 - lib/tjson/datatype/timestamp.rb
-- lib/tjson/datatype/value.rb
 - lib/tjson/object.rb
 - lib/tjson/version.rb
 - tjson.gemspec
@@ -81,12 +81,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []