json2ruby 0.1.0

data/lib/json2ruby/collection.rb

@@ -0,0 +1,63 @@
+require 'digest/md5'
+
+module JSON2Ruby
+  class Collection
+    attr_accessor :name, :original_name, :ruby_types
+
+    def self.short_name
+      "Collection"
+    end
+
+    def initialize(name, ruby_types = {})
+      @name = name
+      @ruby_types = ruby_types
+    end
+
+    def self.parse_from(name, obj_array, options = {})
+      ob = self.new(name)
+      obj_array.each do |v|
+        if v.kind_of?(Array)
+          arr = Collection.parse_from(Entity.get_next_unknown, v, options)
+          ob.ruby_types[arr.attr_hash] = arr
+        elsif v.kind_of?(String)
+          ob.ruby_types[RUBYSTRING.attr_hash] = RUBYSTRING
+        elsif v.kind_of?(Integer) && !options[:forcenumeric]
+          ob.ruby_types[RUBYINTEGER.attr_hash] = RUBYINTEGER
+        elsif v.kind_of?(Float) && !options[:forcenumeric]
+          ob.ruby_types[RUBYFLOAT.attr_hash] = RUBYFLOAT
+        elsif (v.kind_of?(Float) || v.kind_of?(Integer)) && options[:forcenumeric]
+          ob.ruby_types[RUBYNUMERIC.attr_hash] = RUBYNUMERIC
+        elsif !!v==v
+          ob.ruby_types[RUBYBOOLEAN.attr_hash] = RUBYBOOLEAN
+        elsif v.kind_of?(Hash)
+          ent = Entity.parse_from(Entity.get_next_unknown, v, options)
+          ob.ruby_types[ent.attr_hash] = ent
+        end
+      end
+
+      x = ob.attr_hash
+      return Entity.entities[x] if Entity.entities.has_key?(x)
+      Entity.entities[x] = ob
+      ob
+    end
+
+    def attr_hash
+      md5 = Digest::MD5.new
+      @ruby_types.each do |k,typ|
+        md5.update typ.attr_hash
+      end
+      md5.hexdigest
+    end
+
+    def ==(other)
+      return false if other.class != self.class
+      attr_hash == other.attr_hash
+    end
+
+    def comment
+      x = "#{@name}[]"
+      x += " (#{@original_name})" unless @original_name.nil?
+      x
+    end
+  end
+end

data/lib/json2ruby/entity.rb

@@ -0,0 +1,91 @@
+require 'digest/md5'
+
+module JSON2Ruby
+
+  class Entity
+    attr_accessor :name, :original_name, :attributes
+
+    def self.short_name
+      "Entity"
+    end
+
+    def initialize(name, attributes = {})
+      @name = name
+      @attributes = attributes
+    end
+
+    def attr_hash
+      md5 = Digest::MD5.new
+      @attributes.each do |k,v|
+        md5.update "#{k}:#{v.attr_hash}"
+      end
+      md5.hexdigest
+    end
+
+    def ==(other)
+      return false if other.class != self.class
+      attr_hash == other.attr_hash
+    end
+
+    def self.reset_parse
+      @@objs = {
+        RUBYSTRING.attr_hash => RUBYSTRING,
+        RUBYINTEGER.attr_hash => RUBYINTEGER,
+        RUBYFLOAT.attr_hash => RUBYFLOAT,
+        RUBYBOOLEAN.attr_hash => RUBYBOOLEAN,
+        RUBYNUMERIC.attr_hash => RUBYNUMERIC,
+      }
+      @@unknowncount = 0
+    end
+
+    def self.parse_from(name, obj_hash, options = {})
+      ob = self.new(name)
+      obj_hash.each do |k,v|
+
+        orig = k
+        k = k.gsub(/[^A-Za-z0-9_]/, "_")
+
+        if v.kind_of?(Array)
+          att = Collection.parse_from(k, v, options)
+        elsif v.kind_of?(String)
+          att = RUBYSTRING
+        elsif v.kind_of?(Integer) && !options[:forcenumeric]
+          att = RUBYINTEGER
+        elsif v.kind_of?(Float) && !options[:forcenumeric]
+          att = RUBYFLOAT
+        elsif (v.kind_of?(Integer) || v.kind_of?(Float)) && options[:forcenumeric]
+          att = RUBYNUMERIC
+        elsif !!v==v
+          att = RUBYBOOLEAN
+        elsif v.kind_of?(Hash)
+          att = self.parse_from(k, v, options)
+        end
+        att.original_name = orig if orig != k
+        ob.attributes[k] = att
+      end
+
+      x = ob.attr_hash
+      return @@objs[x] if @@objs.has_key?(x)
+      @@objs[x] = ob
+      ob
+    end
+
+    def self.entities
+      @@objs
+    end
+
+    def self.get_next_unknown
+      @@unknowncount ||= 0
+      @@unknowncount += 1
+      "Unknown#{@@unknowncount}"
+    end
+
+    def comment
+      x = @name
+      x += " (#{@original_name})" unless @original_name.nil?
+      x
+    end
+
+    reset_parse
+  end
+end

data/lib/json2ruby/primitive.rb

@@ -0,0 +1,34 @@
+module JSON2Ruby
+
+  class Primitive
+    attr_accessor :name, :original_name, :attr_hash
+
+    def self.short_name
+      "Primitive"
+    end
+
+    def initialize(name, attr_hash)
+      @name = name
+      @attr_hash = attr_hash
+    end
+
+    def attr_hash
+      @attr_hash
+    end
+
+    def comment
+      @name
+    end
+  end
+
+  # Primitive Representing a Ruby String
+  RUBYSTRING = Primitive.new("String","0123456789ABCDEF0123456789ABCDEF")
+  # Primitive Representing a Ruby Integer
+  RUBYINTEGER = Primitive.new("Integer","0123456789ABCDEF0123456789ABCDE0")
+  # Primitive Representing a Ruby Float
+  RUBYFLOAT = Primitive.new("Float","0123456789ABCDEF0123456789ABCDE1")
+  # Primitive Representing a Ruby Boolean
+  RUBYBOOLEAN = Primitive.new("Boolean","0123456789ABCDEF0123456789ABCDE2")
+  # Psuedo-Primitive Representing a Numeric
+  RUBYNUMERIC = Primitive.new("Numeric","0123456789ABCDEF0123456789ABCDE2")
+end

data/lib/json2ruby/ruby_writer.rb

@@ -0,0 +1,50 @@
+require 'digest/md5'
+require 'json'
+require 'optparse'
+
+module JSON2Ruby
+  class RubyWriter
+    def self.to_code(entity, indent = 0, options = {})
+      x = ""
+      if options.has_key?(:require)
+        options[:require].each { |r| x += "require '#{r}'\r\n" }
+        x += "\r\n"
+      end
+      idt = (' '*indent)
+      x += "#{(' '*indent)}#{options[:modules] ? "module" : "class"} #{entity.name}"
+      x += " < #{options[:superclass_name]}" if options.has_key?(:superclass_name)
+      x += "\r\n"
+      if options.has_key?(:extend)
+        options[:extend].each { |r| x += "#{(' '*(indent+2))}extend #{r}\r\n" }
+        x += "\r\n"
+      end
+      if options.has_key?(:include)
+        options[:include].each { |r| x += "#{(' '*(indent+2))}include #{r}\r\n" }
+        x += "\r\n"
+      end
+      x += attributes_to_ruby(entity, indent+2, options)
+      x += "#{(' '*indent)}end\r\n"
+      x
+    end
+
+    def self.attributes_to_ruby(entity, indent, options = {})
+      ident = (' '*indent)
+      x = ""
+      entity.attributes.each do |k,v|
+        if (v.is_a?(Collection))
+          x += "#{ident}#{options[:collectionmethod]} :#{k}"
+        else
+          x += "#{ident}#{options[:attributemethod]} :#{k}"
+        end
+        if options[:includetypes]
+          unless v.is_a?(Primitive)
+            name = !options[:namespace].nil? && options[:namespace]!="" ? (options[:namespace]+"::"+v.name) : v.name
+            x += ", '#{name}'"
+          end
+        end
+        x += " # #{v.comment}\r\n"
+      end
+      x
+    end
+  end
+end

data/lib/json2ruby/version.rb

@@ -0,0 +1,3 @@
+module JSON2Ruby
+  VERSION = '0.1.0'
+end

data/spec/attribute_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe JSON2Ruby::Attribute do
+  describe '#initialize' do
+    it 'should set up correct attrs' do
+      x = JSON2Ruby::Attribute.new('hello','world')
+      expect(x.name).to eq("hello")
+      expect(x.ruby_type).to eq("world")
+    end
+
+    it 'should have correct defaults' do
+      x = JSON2Ruby::Attribute.new('hello')
+      expect(x.name).to eq("hello")
+      expect(x.ruby_type).to eq("_unknown")
+    end
+  end
+
+  describe '#short_name' do
+    it 'should have the correct short name' do
+      expect(JSON2Ruby::Attribute.short_name).to eq('Attribute')
+    end
+  end
+
+  describe '#attr_hash' do
+    it 'should return correct hash' do
+      x = JSON2Ruby::Attribute.new('hello','world')
+      expect(x.attr_hash).to eq("6de41d334b7ce946682da48776a10bb9")
+      x = JSON2Ruby::Attribute.new('foo','bar')
+      expect(x.attr_hash).to eq("4e99e8c12de7e01535248d2bac85e732")
+      x = JSON2Ruby::Attribute.new('hello','bar')
+      expect(x.attr_hash).to eq("4b8ef9a9e864fb4035c8e45d41b085f7")
+      x = JSON2Ruby::Attribute.new('foo','world')
+      expect(x.attr_hash).to eq("b4738da083596d81a33ec6aabba9460b")
+    end
+  end
+
+  describe '#==' do
+    it 'should return false if class mismatch' do
+      x = JSON2Ruby::Attribute.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
+      x = JSON2Ruby::Attribute.new('hello','world')
+      y = JSON2Ruby::Attribute.new('foo','bar')
+      z = JSON2Ruby::Attribute.new('hello','world')
+
+      expect(x==x).to be(true)
+      expect(x==y).to be(false)
+      expect(x==z).to be(true)
+    end
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,310 @@
+require 'spec_helper'
+
+describe JSON2Ruby::CLI do
+
+  describe '#run' do
+    it 'should call in correct order' do
+      options = { :one => 1, :outputdir => File.dirname(__FILE__) }
+
+      expect(JSON2Ruby::CLI).to receive(:puts).with("json2ruby v#{JSON2Ruby::VERSION}\n")
+      expect(JSON2Ruby::CLI).to receive(:get_cli_options).and_return(options)
+      expect(JSON2Ruby::CLI).to receive(:ensure_output_dir).with(options)
+      expect(JSON2Ruby::CLI).to receive(:parse_files).with(options).and_return("rootclasses")
+      expect(JSON2Ruby::CLI).to receive(:write_files).with("rootclasses",JSON2Ruby::RubyWriter,options)
+
+      JSON2Ruby::CLI.run
+    end
+  end
+
+  describe '#ensure_output_dir' do
+    it 'should check dir and create if necessary' do
+      dir =  File.dirname(__FILE__)
+      options = { :one => 1, :outputdir => dir }
+
+      expect(Dir).to receive(:exists?).with(dir).and_return(false)
+      expect(Dir).to receive(:mkdir).with(dir)
+
+      expect(JSON2Ruby::CLI).not_to receive(:puts)
+
+      JSON2Ruby::CLI.ensure_output_dir(options)
+    end
+
+    it 'should not create dir if exists' do
+      dir =  File.dirname(__FILE__)
+      options = { :one => 1, :outputdir => dir }
+
+      expect(Dir).to receive(:exists?).with(dir).and_return(true)
+      expect(Dir).not_to receive(:mkdir)
+
+      JSON2Ruby::CLI.ensure_output_dir(options)
+    end
+
+    it 'should be verbose if option set' do
+      dir =  File.dirname(__FILE__)
+      options = { :one => 1, :outputdir => dir, :verbose =>true }
+
+      expect(Dir).to receive(:exists?).with(dir).and_return(false)
+      expect(Dir).to receive(:mkdir).with(dir)
+
+      expect(JSON2Ruby::CLI).to receive(:puts).with("Output Directory: #{dir}")
+      expect(JSON2Ruby::CLI).to receive(:puts).with("Creating Output Directory...")
+
+      JSON2Ruby::CLI.ensure_output_dir(options)
+    end
+  end
+
+  describe '#get_cli_options' do
+  
+    it 'should have correct defaults' do
+      ARGV = []
+      expect(JSON2Ruby::CLI.get_cli_options).to eq({
+        :outputdir=> File.expand_path("../classes",File.dirname(__FILE__)), 
+        :namespace=>"", 
+        :attributemethod=>"attr_accessor", 
+        :collectionmethod=>"attr_accessor", 
+        :includetypes=>false, 
+        :baseless=>false,
+        :forceoverwrite=>false, 
+        :verbose=>false, 
+        :modulenames=>[]
+      })
+    end
+
+    it 'should parse -o' do
+      ARGV=["-o","test"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:outputdir]).to eq("test")
+    end
+
+    it 'should parse -n' do
+      ARGV=["-n","TEST::TEST2"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:namespace]).to eq("TEST::TEST2")
+    end
+
+    it 'should parse -s' do
+      ARGV=["-s","TEST"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:superclass_name]).to eq("TEST")
+    end
+
+    it 'should parse -r' do
+      ARGV=["-r","json/test"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:require]).to eq(["json/test"])
+    end
+
+    it 'should parse multiple -r' do
+      ARGV=["-r","json/test","-r","onetwo"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:require]).to eq(["json/test","onetwo"])
+    end
+
+    it 'should parse -i' do
+      ARGV=["-i","json/test"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:include]).to eq(["json/test"])
+    end
+
+    it 'should parse multiple -i' do
+      ARGV=["-i","json/test","-i","onetwo"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:include]).to eq(["json/test","onetwo"])
+    end
+
+    it 'should parse -e' do
+      ARGV=["-e","json/test"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:extend]).to eq(["json/test"])
+    end
+
+    it 'should parse multiple -e' do
+      ARGV=["-e","json/test","-e","onetwo"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:extend]).to eq(["json/test","onetwo"])
+    end
+
+    it 'should parse -M' do
+      ARGV=["-M","-e","one"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:modules]).to eq(true)
+    end
+
+    it 'should parse -a' do
+      ARGV=["-a","TESTA"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:attributemethod]).to eq("TESTA")
+    end
+
+     it 'should parse -c' do
+      ARGV=["-c","TESTB"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:collectionmethod]).to eq("TESTB")
+    end
+
+    it 'should parse -t' do
+      ARGV=["-t"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:includetypes]).to eq(true)
+    end
+
+    it 'should parse -b' do
+      ARGV=["-b"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:baseless]).to eq(true)
+    end
+
+    it 'should parse -f' do
+      ARGV=["-f"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:forceoverwrite]).to eq(true)
+    end
+
+    it 'should parse -N' do
+      ARGV=["-N"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:forcenumeric]).to eq(true)
+    end
+
+    it 'should parse -v' do
+      ARGV=["-v"]
+      options = JSON2Ruby::CLI.get_cli_options
+      expect(options[:verbose]).to eq(true)
+    end
+  end
+
+  describe '#self.parse_files' do
+    it 'should reset entity and parse from files' do
+      options = {
+        :verbose => false
+      }
+
+      ARGV = ['/test/to/file','/test/to/file2']
+
+      expect(File).to receive(:read).with("/test/to/file").and_return('{"one":1}')
+      expect(File).to receive(:read).with("/test/to/file2").and_return('{"two":2}')
+
+      expect(JSON2Ruby::Entity).to receive(:parse_from).with("file", {"one"=>1}, options).and_return(3)
+      expect(JSON2Ruby::Entity).to receive(:parse_from).with("file2", {"two"=>2}, options).and_return(4)
+
+      expect(JSON2Ruby::CLI.parse_files(options)).to eq([3,4])
+    end
+
+    it 'should be verbose when option set' do
+    end
+  end
+
+  describe '#self.write_files' do
+    it 'should call File.exists? and File.write with correct data' do
+      options = { :one => 1, :outputdir => File.dirname(__FILE__), :modulenames => [ "TestModule" ] }
+
+      ent = JSON2Ruby::Entity.new("TestEntity", { "one" => JSON2Ruby::RUBYSTRING }) 
+      ents = { ent.attr_hash => ent }
+
+      JSON2Ruby::Entity.class_variable_set(:@@objs, ents)
+
+      writer = {}
+      expect(writer).to receive(:to_code).with(ent,2,options).and_return("CODE")
+
+      expect(File).to receive(:exists?).with("#{options[:outputdir]}/TestEntity.rb").and_return(false)
+      expect(File).to receive(:write).with("#{options[:outputdir]}/TestEntity.rb", "module TestModule\r\nCODEend\r\n")
+
+      expect(JSON2Ruby::CLI).to receive(:puts).with("Done, Generated 1 file")
+
+      JSON2Ruby::CLI.write_files([],writer, options)
+    end
+
+    it 'should not write collections' do
+      options = { :one => 1, :outputdir => File.dirname(__FILE__), :modulenames => [ "TestModule" ] }
+
+      ents = {}
+      ent = JSON2Ruby::Collection.new("TestCollection", { }) 
+      ents[ent.attr_hash] = ent
+
+      ent = JSON2Ruby::Entity.new("TestEntity", { "one" => JSON2Ruby::RUBYSTRING }) 
+      ents[ent.attr_hash] = ent
+
+      JSON2Ruby::Entity.class_variable_set(:@@objs, ents)
+
+      writer = {}
+      expect(writer).to receive(:to_code).with(ent,2,options).and_return("CODE")
+
+      expect(File).to receive(:exists?).with("#{options[:outputdir]}/TestEntity.rb").and_return(false)
+      expect(File).to receive(:write).with("#{options[:outputdir]}/TestEntity.rb", "module TestModule\r\nCODEend\r\n")
+
+      expect(JSON2Ruby::CLI).to receive(:puts).with("Done, Generated 1 file")
+
+      JSON2Ruby::CLI.write_files([],writer, options)
+    end
+
+    it 'should alert and not write file if it exists and not --forceoverwrite' do
+      options = { :one => 1, :outputdir => File.dirname(__FILE__), :modulenames => [ "TestModule" ] }
+
+      ent = JSON2Ruby::Entity.new("TestEntity", { "one" => JSON2Ruby::RUBYSTRING }) 
+      ents = { ent.attr_hash => ent }
+
+      JSON2Ruby::Entity.class_variable_set(:@@objs, ents)
+
+      writer = {}
+      expect(writer).to receive(:to_code).with(ent,2,options).and_return("CODE")
+
+      expect(File).to receive(:exists?).with("#{options[:outputdir]}/TestEntity.rb").and_return(true)
+      expect(File).not_to receive(:write)
+
+      expect($stderr).to receive(:puts).with("File #{options[:outputdir]}/TestEntity.rb exists. Use -f to overwrite.")
+
+      expect(JSON2Ruby::CLI).to receive(:puts).with("Done, Generated 0 files")
+
+      JSON2Ruby::CLI.write_files([],writer, options)
+    end
+
+    it 'should write file if it exists and --forceoverwrite' do
+      options = { :one => 1, :outputdir => File.dirname(__FILE__), :modulenames => [ "TestModule" ], :forceoverwrite=>true }
+
+      ent = JSON2Ruby::Entity.new("TestEntity", { "one" => JSON2Ruby::RUBYSTRING }) 
+      ents = { ent.attr_hash => ent }
+
+      JSON2Ruby::Entity.class_variable_set(:@@objs, ents)
+
+      writer = {}
+      expect(writer).to receive(:to_code).with(ent,2,options).and_return("CODE")
+
+      expect(File).to receive(:exists?).with("#{options[:outputdir]}/TestEntity.rb").and_return(true)
+      expect(File).to receive(:write).with("#{options[:outputdir]}/TestEntity.rb", "module TestModule\r\nCODEend\r\n")
+
+      expect(JSON2Ruby::CLI).to receive(:puts).with("Done, Generated 1 file")
+
+      JSON2Ruby::CLI.write_files([],writer, options)
+    end
+  end
+
+  describe '#self.display_entity' do
+    it 'should call puts correctly for entity' do
+      ent = JSON2Ruby::Entity.new("TestEntity")
+      ent.attributes = {
+        "test1" => JSON2Ruby::Attribute.new("testAttr"),
+        "testEntity" => JSON2Ruby::Entity.new("testEntity"),
+        "testCollection" => JSON2Ruby::Collection.new("testCol"),
+      }
+
+      expect(JSON2Ruby::CLI).to receive(:puts).with("- TestEntity (Entity - 012345670123456789ABCDEF89ABCDEF)")
+      expect(JSON2Ruby::CLI).to receive(:puts).with("  test1: testAttr")
+      expect(JSON2Ruby::CLI).to receive(:puts).with("  testEntity: testEntity")
+      expect(JSON2Ruby::CLI).to receive(:puts).with("  testCollection: testCol")
+
+      JSON2Ruby::CLI.display_entity("012345670123456789ABCDEF89ABCDEF",ent)
+    end
+
+    it 'should call puts correctly for collection' do
+      ent = JSON2Ruby::Collection.new("TestCollection")
+      ent.ruby_types = {
+       JSON2Ruby::RUBYSTRING.attr_hash => JSON2Ruby::RUBYSTRING
+      }
+
+      expect(JSON2Ruby::CLI).to receive(:puts).with("- TestCollection (Collection - 0123456701234567222BCDEF89ABCDEF)")
+      expect(JSON2Ruby::CLI).to receive(:puts).with("  (Types): String")
+
+      JSON2Ruby::CLI.display_entity("0123456701234567222BCDEF89ABCDEF",ent)
+    end
+  end
+end