json2ruby 0.1.0

data/spec/collection_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe JSON2Ruby::Collection do
+  describe '#initialize' do
+    it 'should set up correct attrs' do
+      x = JSON2Ruby::Collection.new('hello',{ :test => 1, :test2 => 2})
+      expect(x.name).to eq("hello")
+      expect(x.ruby_types).to eq({ :test => 1, :test2 => 2})
+    end
+
+    it 'should have the correct defaults' do
+      x = JSON2Ruby::Collection.new('hello')
+      expect(x.name).to eq("hello")
+      expect(x.ruby_types).to eq({})
+    end
+  end
+
+  describe '#short_name' do
+    it 'should have the correct short name' do
+      expect(JSON2Ruby::Collection.short_name).to eq('Collection')
+    end
+  end
+
+  describe '#self.parse_from' do
+    it 'should parse' do
+      obj = [
+        "one",
+        2,
+        3.14,
+        true,
+        {
+          "five" => 5
+        },
+        [
+          "six"
+        ]
+      ]
+
+      col = JSON2Ruby::Collection.parse_from("Test",obj)
+
+      expect(col).to be_a(JSON2Ruby::Collection)
+      expect(col.name).to eq("Test")
+      expect(col.ruby_types.length).to eq(6)
+      expect(col.attr_hash).to eq("6c7447d1288a16012372de22075fdc19")
+    end
+
+    it 'should use numeric instead of int/float when told to' do
+      obj = [
+        "one",
+        2,
+        3.14,
+        true,
+        {
+          "five" => 5
+        },
+        [
+          "six"
+        ]
+      ]
+
+      col = JSON2Ruby::Collection.parse_from("Test",obj, {:forcenumeric=>true})
+
+      expect(col).to be_a(JSON2Ruby::Collection)
+      expect(col.name).to eq("Test")
+      expect(col.ruby_types.length).to eq(4)
+      expect(col.attr_hash).to eq("e38d96234bfbf21545ed4ab2128b9ab4")
+    end
+  end
+
+  describe '#attr_hash' do
+    it 'should return correct hash' do
+      types = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+        JSON2Ruby::RUBYINTEGER.attr_hash => JSON2Ruby::RUBYINTEGER,
+      }
+      x = JSON2Ruby::Collection.new('hello',types)
+      expect(x.attr_hash).to eq("b99a7214ee0aa2cb312890eb5374aa20")
+
+      x.ruby_types = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+      }
+      expect(x.attr_hash).to eq("5392fad6bee373074dbd3edfae6506f2")
+    end
+  end
+
+  describe '#==' do
+    it 'should return false if class mismatch' do
+      x = JSON2Ruby::Collection.new('hello','world')
+
+      expect(x=={}).to be(false)
+      expect(x==[]).to be(false)
+      expect(x==1).to be(false)
+      expect(x=="hello").to be(false)
+      expect(x==nil).to be(false)
+    end
+
+    it 'should return true if and only if attr_hash matches' do
+      types = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+        JSON2Ruby::RUBYINTEGER.attr_hash => JSON2Ruby::RUBYINTEGER,
+      }
+      x = JSON2Ruby::Collection.new('hello',types)
+
+      types = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+      }
+      y = JSON2Ruby::Collection.new('hello',types)
+
+      types = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+        JSON2Ruby::RUBYINTEGER.attr_hash => JSON2Ruby::RUBYINTEGER,
+      }
+      z = JSON2Ruby::Collection.new('hello',types)
+
+      expect(x==x).to be(true)
+      expect(x==y).to be(false)
+      expect(x==z).to be(true)
+    end
+  end
+
+  describe '#comment' do
+    it 'should return correct values' do
+      x = JSON2Ruby::Collection.new('hello')
+      expect(x.comment).to eq("hello[]")
+
+      x.original_name = "test!"
+      expect(x.comment).to eq("hello[] (test!)")
+    end
+  end
+end

data/spec/entity_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe JSON2Ruby::Entity do
+  describe '#initialize' do
+    it 'should set up correct attrs' do
+      x = JSON2Ruby::Entity.new('hello',{ :test => 1, :test2 => 2})
+      expect(x.name).to eq("hello")
+      expect(x.attributes).to eq({ :test => 1, :test2 => 2})
+    end
+
+    it 'should have the correct defaults' do
+      x = JSON2Ruby::Entity.new('hello')
+      expect(x.name).to eq("hello")
+      expect(x.attributes).to eq({})
+    end
+  end
+
+  describe '#short_name' do
+    it 'should have the correct short name' do
+      expect(JSON2Ruby::Entity.short_name).to eq('Entity')
+    end
+  end
+
+  describe '#self.parse_from' do
+    it 'should parse' do
+      obj = {
+        "one" => "1",
+        "two" => 2,
+        "three" => 3.14,
+        "four" => true,
+        "five" => {
+          "5.1"=>5.1
+        },
+        "six" => [ 1,2,3 ]
+      }
+
+      ent = JSON2Ruby::Entity.parse_from("Test",obj)
+
+      expect(ent).to be_a(JSON2Ruby::Entity)
+      expect(ent.name).to eq("Test")
+      expect(ent.attributes.length).to eq(6)
+      expect(ent.attr_hash).to eq("e17024aea3f6f3623dda7170697a72dd")
+    end
+
+    it 'should use numeric instead of int/float when told to' do
+      obj = {
+        "one" => "1",
+        "two" => 2,
+        "three" => 3.14,
+        "four" => true,
+        "five" => {
+          "5.1"=>5.1
+        },
+        "six" => [ 1,2,3 ]
+      }
+
+      ent = JSON2Ruby::Entity.parse_from("Test",obj, {:forcenumeric=>true})
+
+      expect(ent).to be_a(JSON2Ruby::Entity)
+      expect(ent.name).to eq("Test")
+      expect(ent.attributes.length).to eq(6)
+      expect(ent.attr_hash).to eq("592884f7d98c4a31b7d641b10636d546")
+    end
+  end
+
+  describe '#attr_hash' do
+    it 'should return correct hash' do
+      attrs = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+        JSON2Ruby::RUBYINTEGER.attr_hash => JSON2Ruby::RUBYINTEGER,
+      }
+      x = JSON2Ruby::Entity.new('hello',attrs)
+      expect(x.attr_hash).to eq("91c9d28d138816b43934d63c0a4b443f")
+
+      x.attributes = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+      }
+      expect(x.attr_hash).to eq("1bf08c8584361b8b12e1278e0e095340")
+    end
+  end
+
+  describe '#==' do
+    it 'should return false if class mismatch' do
+      x = JSON2Ruby::Entity.new('hello','world')
+
+      expect(x=={}).to be(false)
+      expect(x==[]).to be(false)
+      expect(x==1).to be(false)
+      expect(x=="hello").to be(false)
+      expect(x==nil).to be(false)
+    end
+
+    it 'should return true if and only if attr_hash matches' do
+      attrs = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+        JSON2Ruby::RUBYINTEGER.attr_hash => JSON2Ruby::RUBYINTEGER,
+      }
+      x = JSON2Ruby::Entity.new('hello',attrs)
+
+      attrs = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+      }
+      y = JSON2Ruby::Entity.new('hello',attrs)
+
+      attrs = {
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+        JSON2Ruby::RUBYINTEGER.attr_hash => JSON2Ruby::RUBYINTEGER,
+      }
+      z = JSON2Ruby::Entity.new('hello',attrs)
+
+
+      expect(x==x).to be(true)
+      expect(x==y).to be(false)
+      expect(x==z).to be(true)
+    end
+  end
+
+  describe '#self.get_next_unknown' do
+
+    it 'should return different results after each call' do
+
+      x = JSON2Ruby::Entity.get_next_unknown
+      y = JSON2Ruby::Entity.get_next_unknown
+      z = JSON2Ruby::Entity.get_next_unknown
+
+      expect(x==y).to be(false)
+      expect(y==z).to be(false)
+      expect(z==x).to be(false)
+    end
+  end
+
+  describe '#self.reset_parse' do
+    it 'should be standard after reset' do
+      JSON2Ruby::Entity.class_variable_set('@@objs',[1,2,3])
+
+      JSON2Ruby::Entity.reset_parse
+
+      expect(JSON2Ruby::Entity.entities).to eq({
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+        JSON2Ruby::RUBYINTEGER.attr_hash => JSON2Ruby::RUBYINTEGER,
+        JSON2Ruby::RUBYFLOAT.attr_hash => JSON2Ruby::RUBYFLOAT,
+        JSON2Ruby::RUBYBOOLEAN.attr_hash => JSON2Ruby::RUBYBOOLEAN,
+        JSON2Ruby::RUBYNUMERIC.attr_hash => JSON2Ruby::RUBYNUMERIC,
+      })
+    end
+  end
+
+  describe '#self.entities' do
+    it 'should return @@objs' do
+      JSON2Ruby::Entity.class_variable_set('@@objs',[1,2,3])
+      expect(JSON2Ruby::Entity.entities).to eq([1,2,3])
+    end
+
+    it 'should be standard after reset' do
+      JSON2Ruby::Entity.class_variable_set('@@objs',[1,2,3])
+
+      JSON2Ruby::Entity.reset_parse
+
+      expect(JSON2Ruby::Entity.entities).to eq({
+        JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING,
+        JSON2Ruby::RUBYINTEGER.attr_hash => JSON2Ruby::RUBYINTEGER,
+        JSON2Ruby::RUBYFLOAT.attr_hash => JSON2Ruby::RUBYFLOAT,
+        JSON2Ruby::RUBYBOOLEAN.attr_hash => JSON2Ruby::RUBYBOOLEAN,
+        JSON2Ruby::RUBYNUMERIC.attr_hash => JSON2Ruby::RUBYNUMERIC,
+      })
+    end
+  end
+
+  describe '#comment' do
+    it 'should return correct values' do
+      x = JSON2Ruby::Entity.new('hello')
+      expect(x.comment).to eq("hello")
+
+      x.original_name = "test!"
+      expect(x.comment).to eq("hello (test!)")
+    end
+  end
+end

data/spec/primitive_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe JSON2Ruby::Primitive do
+  describe '#initialize' do
+    it 'should set up correct attrs' do
+      x = JSON2Ruby::Primitive.new('hello','world')
+      expect(x.name).to eq("hello")
+      expect(x.attr_hash).to eq("world")
+    end
+  end
+
+  describe '#short_name' do
+    it 'should have the correct short name' do
+      expect(JSON2Ruby::Primitive.short_name).to eq('Primitive')
+    end
+  end
+
+  describe '#attr_hash' do
+    it 'should return hash' do
+      x = JSON2Ruby::Primitive.new('hello','world')
+      expect(x.attr_hash).to eq("world")
+    end
+  end
+
+  describe '#comment' do
+    it 'should return hash' do
+      x = JSON2Ruby::Primitive.new('hello','world')
+      expect(x.comment).to eq("hello")
+    end
+  end
+
+  describe 'Standard Primitives' do
+    it 'should have standard primitives correctly defined' do
+      
+      expect(JSON2Ruby::RUBYSTRING.name).to eq('String')
+      expect(JSON2Ruby::RUBYSTRING.attr_hash).to eq('0123456789ABCDEF0123456789ABCDEF')
+
+      expect(JSON2Ruby::RUBYINTEGER.name).to eq('Integer')
+      expect(JSON2Ruby::RUBYINTEGER.attr_hash).to eq('0123456789ABCDEF0123456789ABCDE0')
+
+      expect(JSON2Ruby::RUBYFLOAT.name).to eq('Float')
+      expect(JSON2Ruby::RUBYFLOAT.attr_hash).to eq('0123456789ABCDEF0123456789ABCDE1')
+
+      expect(JSON2Ruby::RUBYBOOLEAN.name).to eq('Boolean')
+      expect(JSON2Ruby::RUBYBOOLEAN.attr_hash).to eq('0123456789ABCDEF0123456789ABCDE2')
+
+      expect(JSON2Ruby::RUBYNUMERIC.name).to eq('Numeric')
+      expect(JSON2Ruby::RUBYNUMERIC.attr_hash).to eq('0123456789ABCDEF0123456789ABCDE2')
+    end
+  end
+end

data/spec/ruby_writer_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe JSON2Ruby::RubyWriter do
+
+  describe '#to_code' do
+    it 'should return correct code for classes' do
+      entity = OpenStruct.new({ 
+        :name => "TestEntitiy",
+      })
+
+      options = {
+        :require => [ 'recone', 'rectwo', 'recthree' ],
+        :include => [ 'incone', 'inctwo', 'incthree' ],
+        :extend => [ 'excone', 'exctwo', 'excthree' ],
+        :superclass_name => 'Superclass',
+        :modules => false,
+      }
+
+      expect(JSON2Ruby::RubyWriter).to receive(:attributes_to_ruby).with(entity, 2, options).and_return("")
+
+      expect(JSON2Ruby::RubyWriter.to_code(entity,0,options)).to eq("require 'recone'\r\nrequire 'rectwo'\r\nrequire 'recthree'\r\n\r\nclass TestEntitiy < Superclass\r\n  extend excone\r\n  extend exctwo\r\n  extend excthree\r\n\r\n  include incone\r\n  include inctwo\r\n  include incthree\r\n\r\nend\r\n")
+    end
+
+    it 'should return correct code for modules' do
+      entity = OpenStruct.new({ 
+        :name => "TestEntitiy",
+      })
+
+      options = {
+        :require => [ 'recone', 'rectwo', 'recthree' ],
+        :include => [ 'incone', 'inctwo', 'incthree' ],
+        :extend => [ 'excone', 'exctwo', 'excthree' ],
+        :superclass_name => 'Superclass',
+        :modules => true,
+      }
+
+      expect(JSON2Ruby::RubyWriter).to receive(:attributes_to_ruby).with(entity, 2, options).and_return("")
+
+      expect(JSON2Ruby::RubyWriter.to_code(entity,0,options)).to eq("require 'recone'\r\nrequire 'rectwo'\r\nrequire 'recthree'\r\n\r\nmodule TestEntitiy < Superclass\r\n  extend excone\r\n  extend exctwo\r\n  extend excthree\r\n\r\n  include incone\r\n  include inctwo\r\n  include incthree\r\n\r\nend\r\n")
+    end
+  end
+
+  describe '#attributes_to_ruby' do
+    it 'should return correct code for simple attrs' do
+      entity = OpenStruct.new({ 
+        :name => "TestEntitiy",
+        :attributes => {
+          "test1" => OpenStruct.new({:comment => 'test1 comment'}),
+          "test2" => OpenStruct.new({:comment => 'test2 comment'}),
+        }
+      })
+
+      options = {
+        :collectionmethod => 'collectionmethod',
+        :attributemethod => 'attributemethod',
+      }
+
+      expect(JSON2Ruby::RubyWriter.attributes_to_ruby(entity,0,options)).to eq("attributemethod :test1 # test1 comment\r\nattributemethod :test2 # test2 comment\r\n")
+    end
+
+    it 'should return correct code for attrs that are primitives' do
+      entity = OpenStruct.new({ 
+        :name => "TestEntitiy",
+        :attributes => {
+          "test1" => JSON2Ruby::RUBYSTRING,
+          "test2" => OpenStruct.new({:comment => 'test2 comment'}),
+        }
+      })
+
+      options = {
+        :collectionmethod => 'collectionmethod',
+        :attributemethod => 'attributemethod',
+      }
+
+      expect(JSON2Ruby::RubyWriter.attributes_to_ruby(entity,0,options)).to eq("attributemethod :test1 # String\r\nattributemethod :test2 # test2 comment\r\n")
+    end
+
+    it 'should return correct code for collections' do
+      entity = OpenStruct.new({ 
+        :name => "TestEntitiy",
+        :attributes => {
+          "testCollection" => JSON2Ruby::Collection.new("testCol"),
+          "test2" => OpenStruct.new({:comment => 'test2 comment'}),
+        }
+      })
+
+      options = {
+        :collectionmethod => 'collectionmethod',
+        :attributemethod => 'attributemethod',
+      }
+
+      expect(JSON2Ruby::RubyWriter.attributes_to_ruby(entity,0,options)).to eq("collectionmethod :testCollection # testCol[]\r\nattributemethod :test2 # test2 comment\r\n")
+    end
+
+    it 'should return correct code for attrs and include type as second param' do
+      entity = OpenStruct.new({ 
+        :name => "TestEntitiy",
+        :attributes => {
+          "test1" => OpenStruct.new({:comment => 'test1 comment'}),
+          "test2" => OpenStruct.new({:comment => 'test2 comment'}),
+        }
+      })
+
+      options = {
+        :collectionmethod => 'collectionmethod',
+        :attributemethod => 'attributemethod',
+        :includetypes => true,
+      }
+
+      expect(JSON2Ruby::RubyWriter.attributes_to_ruby(entity,0,options)).to eq("attributemethod :test1, '' # test1 comment\r\nattributemethod :test2, '' # test2 comment\r\n")
+    end
+
+
+  end
+
+end