jcon 0.1

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Oliver Steele
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Manifest

@@ -0,0 +1,15 @@
+lib/jcon/conformance.rb
+lib/jcon/dictionary.rb
+lib/jcon/matchers/jcon_matchers.rb
+lib/jcon/parser.rb
+lib/jcon/types.rb
+lib/jcon.rb
+LICENSE
+Manifest
+README
+spec/conformance_spec.rb
+spec/jcon_spec.rb
+spec/matchers_spec.rb
+spec/parser_spec.rb
+spec/spec_helper.rb
+TODO

data/README

@@ -0,0 +1,41 @@
+= JCon -- JavaScript Type Conformance Checking
+
+Test whether a parsed JSON type conforms to a type specification, read
+from a string or file that matches the proposed ECMAScript 4.0 type
+syntax (PDF[http://www.ecmascript.org/es4/spec/overview.pdf]).
+
+
+== Install
+
+  gem install rcon
+
+== Usage
+
+  type = JCON::parse "[string, int]"
+  type.contains?(['a', 1]) # => true
+  type.contains?(['a', 'b']) # => false
+  type.contains?(['a', 1, 2]) # => true
+  
+  type = JCON::parse "type S = (string, int); {a: [S], b: int}"
+  type.contains?({:a => [1, 'b'], :b => 2}) # => true
+
+== RSpec Matcher
+
+  [1, 'xyzzy'].should conform_to_js('[int, string]')
+  [1, 2, 'xyzzy'].should_not conform_to_js('[int, string]')
+  {:x => 1}.should conform_to_js('{x: int}')
+
+Use this with the "JavaScriptFu"[http://osteele.com/archives/2008/04/javascript-fu-rails-plugin] plugin to test JSON arguments:
+
+  '<script>fn("id", {x:1, y:2}, true)</script>'.should call_js('fn') do |args|
+    args[0].should conform_to_js('string')
+    args[1].should conform_to_js('{x:int, y:int}')
+    args[2].should conform_to_js('boolean')
+    # or:
+    args.should conform_to_js('[string, {x:int, y:int}, boolean]')
+  end
+
+== License
+
+Copyright 2008 by Oliver Steele.  All rights reserved.  Released under
+the MIT License.

data/TODO

@@ -0,0 +1,26 @@
+= JCon TODO
+
+Next:
+* docs -- add the README
+* check the spec
+* add method to display path to mismatch
+* rename SimpleType
+
+Error detection:
+* circular references
+* duplicate definitions
+
+Test cases:
+* recursive types
+
+Parser:
+* can property name be string?
+
+Conformance:
+* byte
+
+Future:
+* function(this:T | T | T= | ... | ...[T]) : T | void
+* 'class'
+* js implementation
+* includes

data/jcon.gemspec

@@ -0,0 +1,64 @@
+
+# Gem::Specification for Jcon-0.1
+# Originally generated by Echoe
+
+Gem::Specification.new do |s|
+  s.name = %q{jcon}
+  s.version = "0.1"
+  s.date = %q{2008-04-16}
+  s.summary = %q{Test JSON values against a schema.}
+  s.email = %q{steele@osteele.com}
+  s.homepage = %q{http://jcon.rubyforge.org}
+  s.rubyforge_project = %q{jcon}
+  s.description = %q{Test JSON values for conformance with ECMAScript 4.0 types.}
+  s.has_rdoc = true
+  s.authors = ["Oliver Steele"]
+  s.files = ["lib/jcon/conformance.rb", "lib/jcon/dictionary.rb", "lib/jcon/matchers/jcon_matchers.rb", "lib/jcon/parser.rb", "lib/jcon/types.rb", "lib/jcon.rb", "LICENSE", "Manifest", "README", "spec/conformance_spec.rb", "spec/jcon_spec.rb", "spec/matchers_spec.rb", "spec/parser_spec.rb", "spec/spec_helper.rb", "TODO", "jcon.gemspec"]
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Jcon", "--main", "README", "--title", "JCON: Test JSON values against a schema", "--main", "README", "--exclude", "spec/.*"]
+  s.extra_rdoc_files = ["README", "TODO", "LICENSE"]
+end
+
+
+# # Original Rakefile source (requires the Echoe gem):
+# 
+# require 'rubygems'
+# require 'echoe'
+# require 'spec/rake/spectask'
+# 
+# PKG_VERSION = '0.1'
+# 
+# task :test => :spec
+# 
+# Echoe.new('jcon', PKG_VERSION) do |p|
+#   p.summary       = "Test JSON values against a schema."
+#   p.url           = 'http://jcon.rubyforge.org'
+#   p.description    = <<-EOF
+#     Test JSON values for conformance with ECMAScript 4.0 types.
+#   EOF
+#   p.author         = 'Oliver Steele'
+#   p.email          = 'steele@osteele.com'
+#   p.ignore_pattern = /^(.git|.*#.*#)$/
+#   p.test_pattern   = 'test/*_test.rb'
+#   p.rdoc_pattern   = /^(lib|bin|tasks|ext)|^README|^CHANGES|^TODO|^LICENSE$/
+#   p.eval = proc do |s|
+#     s.rdoc_options <<
+#       '--title' << "JCON: #{s.summary.sub(/.$/,'')}" <<
+#       '--main' << 'README' <<
+#       '--exclude' << 'spec/.*'
+#     s.extra_rdoc_files = ['README', 'TODO', 'LICENSE']
+#   end
+# end
+# 
+# desc "Really a replacement for echoe's 'install', which bombs on my machine"
+# task :reinstall => [:clean, :package, :uninstall] do
+#   system "sudo gem install pkg/*.gem"
+# end
+# 
+# desc "Run all specs"
+# Spec::Rake::SpecTask.new do |t|
+#   t.spec_files = FileList['spec/*_spec.rb']
+#   if ENV['RCOV']
+#     t.rcov = true
+#     t.rcov_opts = ['--exclude', 'spec\/spec']
+#   end
+# end

data/lib/jcon.rb

@@ -0,0 +1,5 @@
+require "jcon/types"
+require "jcon/conformance"
+require "jcon/dictionary"
+require "jcon/parser"
+require "jcon/matchers/jcon_matchers"

data/lib/jcon/conformance.rb

@@ -0,0 +1,57 @@
+module JCON
+  module Types
+    class SimpleType < Type
+      def contains?(value)
+        if not @test and context and@context[name]
+          return context[name].contains?(value)
+        end
+        raise "No definition for #{self}" unless @test
+        @test.call(value)
+      end
+    end
+    
+    class OptionalType < Type
+      def contains?(value)
+        value.nil? or type.contains?(value)
+      end
+    end
+    
+    class RequiredType < Type
+      def contains?(value)
+        !value.nil? and type.contains?(value)
+      end
+    end
+    
+    class ListType < Type
+      def contains?(value)
+        return false unless value.is_a?(Array)
+        return false unless value.length >= types.length
+        value.each_with_index do |x, i|
+          return false unless types[[i, types.length-1].min].contains?(x)
+        end
+        true
+      end
+    end
+    
+    class UnionType < Type
+      def contains?(value)
+        types.any? do |type| type.contains?(value) end
+      end
+    end
+    
+    class RecordType < Type
+      def contains?(value)
+        return false unless value.is_a?(Hash)
+        value.each do |k, v|
+          type = properties["#{k}".intern]
+          return false unless type
+          return false unless type.contains?(v)
+        end
+        properties.each do |k, _|
+          return false unless value.include?(k) or value.include?(k.to_s)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/jcon/dictionary.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(__FILE__), 'types')
+
+module JCON
+  class Dictionary
+    include Types
+    
+    attr_reader :parent, :definitions
+    attr_accessor :start
+    
+    def initialize(parent=BUILTINS)
+      @parent = parent
+      @definitions = {}
+    end
+    
+    def deftype(name, type=nil, &block)
+      return deftype(name, SimpleType.new(name, &block)) if block
+      case type
+      when nil
+        deftype(name, Kernel.const_get(name))
+      when Class
+        deftype(name) do |x| x.nil? or x.is_a?(type) end
+      when Array
+        deftype(name) do |x| type.include?(x) end
+      when Type
+        name = name.intern if name.is_a?(String)
+        @definitions[name] = type
+        @start ||= type
+      else
+        raise "invalid arguments"
+      end
+    end
+    
+    def [](name)
+      @definitions[name] || (parent && parent[name])
+    end
+  end
+  
+  class DefaultDictionary < Dictionary
+    def initialize
+      super(nil)
+      add_builtin_definitions
+    end
+    
+    def add_builtin_definitions
+      deftype(:*) do true end
+      deftype(:null) do |x| x.nil? end
+      deftype(:undefined) do |x| x.nil? end
+      deftype(:Object) do true end
+      deftype(:Array)
+      deftype(:Date)
+      deftype(:RegExp, Regexp)
+      deftype(:Boolean, [false,true,nil])
+      deftype(:String)
+      deftype(:Number, Numeric)
+      deftype(:boolean, [false,true])
+      deftype(:string) do |x| x.is_a?(String) end
+      deftype(:int) do |x| x.is_a?(Integer) end
+      deftype(:uint) do |x| x.is_a?(Integer) and x > 0 end
+      deftype(:double) do |x| x.is_a?(Numeric) end
+      deftype(:decimal) do |x| x.is_a?(Numeric) end
+      deftype :AnyString, union(:string, String)
+      deftype :AnyBoolean, union(:boolean, :Boolean) 
+      deftype :AnyNumber, union(:byte, :int, :uint, :double, :decimal,:Number) 
+      deftype :FloatNumber, union(:double, :decimal) 
+    end
+  end
+  
+  BUILTINS = DefaultDictionary.new
+end

data/lib/jcon/matchers/jcon_matchers.rb

@@ -0,0 +1,26 @@
+module JCON
+  module Matchers
+    class ConformToJSType #:nodoc:
+      def initialize(type_or_text)
+        type = type_or_text
+        type = JCON.parse(type) if String === type
+        @expected = type
+      end
+      
+      def matches?(actual)
+        @expected.contains?(actual)
+      end
+
+      def failure_message; "should #{description}, but did not"; end
+      def negative_failure_message; "should not #{description}, but did"; end
+
+      def description
+        "conform to type #{@expected}"
+      end
+    end
+    
+    def conform_to_js(type_or_text)
+      return ConformToJSType.new(type_or_text)
+    end
+  end
+end

data/lib/jcon/parser.rb

@@ -0,0 +1,127 @@
+require 'strscan'
+
+module JCON
+  def self.parse(source)
+    Parser.parse(source).start
+  end
+  
+  class Parser < StringScanner
+    include Types
+    
+    COMMENT = %r{//.*|/\*(?:.|[\r\n])*?\*/}
+    WS_CHAR = /[\s\r\n]/
+    IGNORE = /(?:#{COMMENT}|#{WS_CHAR})+/
+    IDENTIFIER = /[\w_$][\w\d_$]*/
+
+    def self.parse(source)
+      self.new(source).parse
+    end
+    
+    attr_reader :dictionary
+
+    def initialize(source)
+      super(source)
+      @dictionary = Dictionary.new
+    end
+
+    def parse
+      reset
+      until eos?
+        case
+        when skip(IGNORE)
+        when skip(/;/)
+          ;
+        when scan(/type/)
+          parse_deftype
+        else
+          type = parse_type
+          dictionary.start = type
+          while skip(IGNORE) || skip(/;/); end
+          parse_error "expected end of input" unless eos?  
+        end
+      end
+      dictionary
+    end
+    
+    def parse_deftype
+      name = expect('identifier', IDENTIFIER)
+      expect('=', /=/)
+      type = parse_type
+      dictionary.deftype(name.intern, type)
+      sscan(/;/)
+    end
+    
+    def parse_type
+      skip(IGNORE)
+      type = case
+             when id = scan(IDENTIFIER)
+               simple_type(id)
+             when scan(/\*/)
+               simple_type('*')
+             when scan(/\[/)
+               types = parse_types_until(/\]/)
+               list(*types)
+             when scan(/\(/)
+               types = parse_types_until(/\)/)
+               union(*types)
+             when scan(/\{/)
+               parse_structure_type
+             else
+               parse_error
+             end
+      type.context = dictionary
+      add_modifiers(type)
+    end
+    
+    def add_modifiers(type)
+      while sscan(/[!?]/)
+        case self[0]
+        when '!'
+          type = required(type)
+        when '?'
+          type = optional(type)
+        end
+        type.context = dictionary
+      end
+      type
+    end
+    
+    def parse_types_until(stop_pattern)
+      types = []
+      while true
+        break if sscan(stop_pattern)
+        expect('comma', /,/) if types.any?
+        types << parse_type
+      end
+      types
+    end
+    
+    def parse_structure_type
+      map = {}
+      while true
+        break if sscan(/\}/)
+        expect('comma', /,/) if map.any?
+        name = expect('id', IDENTIFIER)
+        expect(':', /:/)
+        type = parse_type
+        map[name.intern] = type
+      end
+      RecordType.new(map)
+    end
+    
+    def expect(name, pattern)
+      value = sscan(pattern)
+      parse_error("expected #{name}") unless value
+      value
+    end
+
+    def sscan(pattern)
+      skip(IGNORE)
+      scan(pattern)
+    end
+
+    def parse_error(msg='unexpected token')
+      raise "#{msg} at '#{skip(IGNORE); peek(20)}'"
+    end
+  end
+end

data/lib/jcon/types.rb

@@ -0,0 +1,67 @@
+module JCON
+  module Types
+    def self.to_type(value)
+      value = SimpleType.new(value) unless value.is_a?(Type)
+      value
+    end
+    
+    def self.to_types(values)
+      values.map { |value| to_type(value) }
+    end
+    
+    class Type
+      attr_accessor :context
+      def inspect; to_s; end
+    end
+    
+    class SimpleType < Type
+      attr_reader :name
+      def initialize(name, &block)
+        name = name.intern if name.is_a?(String)
+        @name = name
+        @test = block
+      end
+      
+      def to_s; name.to_s; end
+    end
+    
+    class OptionalType < Type
+      attr_reader :type
+      def initialize(type); @type = type; end
+      def to_s; "#{type}?"; end
+    end
+    
+    class RequiredType < Type
+      attr_reader :type
+      def initialize(type); @type = type; end
+      def to_s; "#{type}!"; end
+    end
+    
+    class ListType < Type
+      attr_reader :types
+      def initialize(types); @types = Types.to_types(types); end
+      def to_s; "[#{types.join(', ')}]"; end
+    end
+    
+    class UnionType < Type
+      attr_reader :types
+      def initialize(types); @types = Types.to_types(types); end
+      def to_s; "(#{types.join(', ')})"; end
+    end
+    
+    class RecordType < Type
+      attr_reader :properties
+      def initialize(properties);
+        @properties = properties
+      end
+      
+      def to_s; "{#{properties.map { |k,v| "#{k}: #{v}"}.join(', ')}}"; end
+    end
+    
+    def simple_type(*args); SimpleType.new(*args); end
+    def required(*args); RequiredType.new(*args); end
+    def optional(*args); OptionalType.new(*args); end
+    def list(*args); ListType.new(args); end
+    def union(*args); UnionType.new(args); end
+  end
+end

data/spec/conformance_spec.rb

@@ -0,0 +1,162 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe JCON do
+  describe :conforms? do
+    it "should test the Any type" do
+      type = JCON::parse('*')
+      type.contains?(false).should == true
+      type.contains?(0).should == true
+      type.contains?(1).should == true
+    end
+    
+    it "should test the null type" do
+      type = JCON::parse('null')
+      type.contains?(false).should == false
+      type.contains?(0).should == false
+      type.contains?(nil).should == true
+    end
+    
+    it "should test the undefined type" do
+      type = JCON::parse('undefined')
+      type.contains?(false).should == false
+      type.contains?(0).should == false
+      type.contains?(nil).should == true
+    end
+    
+    it "should test string types" do
+      type = JCON::parse('string')
+      type.contains?(1).should == false
+      type.contains?('s').should == true
+      type.contains?(nil).should == false
+      
+      type = JCON::parse('String')
+      type.contains?(1).should == false
+      type.contains?('s').should == true
+      type.contains?(nil).should == true
+    end
+    
+    it "should test numeric types" do
+      type = JCON::parse('Number')
+      type.contains?(1).should == true
+      type.contains?('s').should == false
+      type.contains?(nil).should == true
+      
+      type = JCON::parse('int')
+      type.contains?(1).should == true
+      type.contains?(1.5).should == false
+      type.contains?('s').should == false
+      type.contains?(nil).should == false
+      
+      type = JCON::parse('uint')
+      type.contains?(1).should == true
+      type.contains?(1.5).should == false
+      type.contains?(-1).should == false
+      type.contains?(nil).should == false
+      
+      type = JCON::parse('double')
+      type.contains?(1).should == true
+      type.contains?(1.5).should == true
+      type.contains?(nil).should == false
+      
+      type = JCON::parse('decimal')
+      type.contains?(1).should == true
+      type.contains?(1.5).should == true
+      type.contains?(nil).should == false
+    end
+    
+    it "should test object types" do
+      type = JCON::parse('Object')
+      type.contains?(1).should == true
+      type.contains?('s').should == true
+      type.contains?([]).should == true
+      type.contains?({}).should == true
+      type.contains?(nil).should == true
+      
+      type = JCON::parse('Array')
+      type.contains?(1).should == false
+      type.contains?('s').should == false
+      type.contains?([]).should == true
+      type.contains?({}).should == false
+      type.contains?(nil).should == true
+      
+      type = JCON::parse('Date')
+      type.contains?(1).should == false
+      type.contains?('s').should == false
+      type.contains?(Date.new).should == true
+      type.contains?({}).should == false
+      type.contains?(nil).should == true
+      
+      type = JCON::parse('RegExp')
+      type.contains?(1).should == false
+      type.contains?('s').should == false
+      type.contains?(/s/).should == true
+      type.contains?({}).should == false
+      type.contains?(nil).should == true
+    end
+    
+    it "should test optional types" do
+      type = JCON::parse('int?')
+      type.contains?(1).should == true
+      type.contains?(nil).should == true
+    end
+    
+    it "should test required types" do
+      type = JCON::parse('Object!')
+      type.contains?(1).should == true
+      type.contains?(nil).should == false
+      
+      type = JCON::parse('Number!')
+      type.contains?(1).should == true
+      type.contains?(nil).should == false
+    end
+    
+    it "should test union types" do
+      type = JCON::parse('(string, boolean)')
+      type.contains?('s').should == true
+      type.contains?(true).should == true
+      type.contains?(1).should == false
+      type.contains?(nil).should == false
+    end
+    
+    it "should test list types" do
+      type = JCON::parse('[string, boolean]')
+      type.contains?('s').should == false
+      type.contains?([]).should == false
+      type.contains?([1]).should == false
+      type.contains?([1,2]).should == false
+      type.contains?([1,2,3]).should == false
+      type.contains?(['s']).should == false
+      type.contains?(['s',2]).should == false
+      type.contains?([1,true]).should == false
+      type.contains?(['s',true]).should == true
+      type.contains?(['s',true,true]).should == true
+      type.contains?(['s',true,3]).should == false
+    end
+    
+    it "should test record types" do
+      type = JCON::parse('{a:int, b:string}')
+      type.contains?('s').should == false
+      
+      type.contains?({:a => 1}).should == false
+      type.contains?({:b => 's'}).should == false
+      type.contains?({:a => 1, :b => 's'}).should == true
+      type.contains?({:a => 's', :b => 's'}).should == false
+      type.contains?({:a => 1, :b => 2}).should == false
+      type.contains?({:a => 1, :b => 's', :c => false}).should == false
+      
+      type.contains?({'a' => 1}).should == false
+      type.contains?({'b' => 's'}).should == false
+      type.contains?({'a' => 1, 'b' => 's'}).should == true
+      type.contains?({'a' => 's', 'b' => 's'}).should == false
+      type.contains?({'a' => 1, 'b' => 2}).should == false
+      type.contains?({'a' => 1, 'b' => 's', :c => false}).should == false
+    end
+    
+    it "should test type definitions"
+    
+    it "should raise an error when for unknown" do
+      type = JCON::parse('S')
+      lambda { type.contains?('s') }.should raise_error('No definition for S')
+    end
+  end
+end

data/spec/jcon_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe JCON do
+  describe :parse do
+    it "parse should return a type" do
+      type = JCON::parse('string')
+      type.should be_an_instance_of(JCON::Types::SimpleType)
+    end
+  end
+end

data/spec/matchers_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe JCON::Matchers do
+  include JCON::Matchers
+  
+  describe :conforms_to_js do
+    it "should test basic types" do
+      1.should conform_to_js('int')
+      1.should_not conform_to_js('string')
+      's'.should conform_to_js('string')
+      's'.should_not conform_to_js('int')
+      lambda { 1.should conform_to_js('string') }.should raise_error('should conform to type string, but did not')
+      lambda { 1.should_not conform_to_js('int') }.should raise_error('should not conform to type int, but did')
+    end
+    
+    it "should test nullability" do
+      1.should conform_to_js('int')
+      nil.should_not conform_to_js('int')
+      1.should conform_to_js('Number')
+      nil.should conform_to_js('Number')
+      1.should conform_to_js('int!')
+      nil.should_not conform_to_js('int!')
+      1.should conform_to_js('Number!')
+      nil.should_not conform_to_js('Number!')
+      1.should conform_to_js('int?')
+      nil.should conform_to_js('int?')
+      1.should conform_to_js('Number?')
+      nil.should conform_to_js('Number?')
+    end
+    
+    it "should test more complex cases" do
+      [[1], 2].should conform_to_js('[Array, (int, boolean)]')
+      [[1], true].should conform_to_js('[Array, (int, boolean)]')
+      [[1], 2, true].should conform_to_js('[Array, (int, boolean)]')
+      [].should_not conform_to_js('[Array, (int, boolean)]')
+      [1, 2].should_not conform_to_js('[Array, (int, boolean)]')
+      [[1], nil].should_not conform_to_js('[Array, (int, boolean)]')
+      {'x' => 1, 'y' => 2, 'z' => 3}.should conform_to_js('{x: double, y: double, z: double?}')
+      [[[1], 2], {'x' => 1, 'y' => 2, 'z' => 3}].should conform_to_js('[[Array, (int, boolean)], {x: double, y: double, z: double?}]')
+    end
+    
+    it "should work with the examples in the README" do
+      [1, 'xyzzy'].should conform_to_js('[int, string]')
+      [1, 2, 'xyzzy'].should_not conform_to_js('[int, string]')
+      {:x => 1}.should conform_to_js('{x: int}')
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe JCON::Parser do
+  describe :parse do
+    it "should parse a bare type" do
+      type = JCON::Parser.parse('string').start
+      type.should be_an_instance_of(JCON::Types::SimpleType)
+    end
+    
+    it "should parse a union type" do
+      type = JCON::Parser.parse('(string, String)').start
+      type.should be_an_instance_of(JCON::Types::UnionType)
+      type.types.length.should == 2
+      type.types[0].name.should == :string
+      type.types[1].name.should == :String
+    end
+    
+    it "should parse a list type" do
+      type = JCON::Parser.parse('[string, String]').start
+      type.should be_an_instance_of(JCON::Types::ListType)
+      type.types.length.should == 2
+      type.types[0].name.should == :string
+      type.types[1].name.should == :String
+    end
+    
+    it "should parse a required type" do
+      type = JCON::Parser.parse('string!').start
+      type.should be_an_instance_of(JCON::Types::RequiredType)
+    end
+    
+    it "should parse an optional type" do
+      type = JCON::Parser.parse('type T = string?')[:T]
+      type.should be_an_instance_of(JCON::Types::OptionalType)
+    end
+    
+    it "should parse a record type" do
+      type = JCON::Parser.parse('type T = {a:string?, b:int}')[:T]
+      type.should be_an_instance_of(JCON::Types::RecordType)
+    end
+    
+    it "should parse a basic type definition" do
+      type = JCON::Parser.parse('type T = string')[:T]
+      type.should be_an_instance_of(JCON::Types::SimpleType)
+    end
+    
+    it "should parse two type definitions" do
+      dict = JCON::Parser.parse('type T = string; type U = String;')
+      dict.definitions.length.should == 2
+      dict[:U].should be_an_instance_of(JCON::Types::SimpleType)
+      dict[:T].should be_an_instance_of(JCON::Types::SimpleType)
+    end
+    
+    it "should parse a union type definition" do
+      type = JCON::Parser.parse('type T = (string, String)')[:T]
+      type.should be_an_instance_of(JCON::Types::UnionType)
+      type.types.length.should == 2
+      type.types[0].name.should == :string
+      type.types[1].name.should == :String
+    end
+    
+    it "should ignore extraneous semicolons" do
+      dict = JCON::Parser.parse(';type T = string')
+      dict.definitions.length.should == 1
+      dict = JCON::Parser.parse(';;type T = string')
+      dict.definitions.length.should == 1
+      dict = JCON::Parser.parse('type T = string;')
+      dict.definitions.length.should == 1
+      dict = JCON::Parser.parse('type T = string;;')
+      dict.definitions.length.should == 1
+      dict = JCON::Parser.parse('type T = string;type U = String;')
+      dict.definitions.length.should == 2
+      dict = JCON::Parser.parse(';;string;;')
+      dict.start.should be_an_instance_of(JCON::Types::SimpleType)
+    end
+    
+    it "should ignore comments" do
+      JCON::Parser.parse("// comment\nstring").start.should be_an_instance_of(JCON::Types::SimpleType)
+      JCON::Parser.parse("string// comment\n").start.should be_an_instance_of(JCON::Types::SimpleType)
+      JCON::Parser.parse("string\n// comment\n").start.should be_an_instance_of(JCON::Types::SimpleType)
+      
+      JCON::Parser.parse("type T = // comment\nstring").definitions.length.should == 1
+      JCON::Parser.parse("type T = // comment\nstring").definitions.length.should == 1
+      JCON::Parser.parse("type T = /* comment */ string").definitions.length.should == 1
+      JCON::Parser.parse("type T = /* multiline\ncomment */ string").definitions.length.should == 1
+    end
+    
+    it "should report parse errors" do
+      lambda { JCON::Parser.parse('type') }.should raise_error("expected identifier at ''")
+      lambda { JCON::Parser.parse('type S') }.should raise_error("expected = at ''")
+      lambda { JCON::Parser.parse('[1') }.should raise_error("expected comma at ''")
+      lambda { JCON::Parser.parse('[1,,') }.should raise_error("unexpected token at ','")
+      lambda { JCON::Parser.parse('[1,]') }.should raise_error("unexpected token at ']'")
+      lambda { JCON::Parser.parse('[1]]') }.should raise_error("expected end of input at ']'")
+      lambda { JCON::Parser.parse('[1 2]') }.should raise_error("expected comma at '2]'")
+      lambda { JCON::Parser.parse('{a') }.should raise_error("expected : at ''")
+      lambda { JCON::Parser.parse('{a:') }.should raise_error("unexpected token at ''")
+      lambda { JCON::Parser.parse('{a:1') }.should raise_error("expected comma at ''")
+      lambda { JCON::Parser.parse('{a:1,') }.should raise_error("expected id at ''")
+      lambda { JCON::Parser.parse('{a:1}}') }.should raise_error("expected end of input at '}'")
+    end
+  end
+  
+  describe :start do
+    it "should return the first definition" do
+      type = JCON::Parser.parse('type T = string; type U = String;').start
+      type.should be_an_instance_of(JCON::Types::SimpleType)
+      type.name.should == :string
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'jcon'

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: jcon
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2008-04-16 00:00:00 -04:00
+summary: Test JSON values against a schema.
+require_paths: 
+- lib
+email: steele@osteele.com
+homepage: http://jcon.rubyforge.org
+rubyforge_project: jcon
+description: Test JSON values for conformance with ECMAScript 4.0 types.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Oliver Steele
+files: 
+- lib/jcon/conformance.rb
+- lib/jcon/dictionary.rb
+- lib/jcon/matchers/jcon_matchers.rb
+- lib/jcon/parser.rb
+- lib/jcon/types.rb
+- lib/jcon.rb
+- LICENSE
+- Manifest
+- README
+- spec/conformance_spec.rb
+- spec/jcon_spec.rb
+- spec/matchers_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- TODO
+- jcon.gemspec
+test_files: []
+
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Jcon
+- --main
+- README
+- --title
+- "JCON: Test JSON values against a schema"
+- --main
+- README
+- --exclude
+- spec/.*
+extra_rdoc_files: 
+- README
+- TODO
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+