class_from_son 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53b0a1472f3977c2b06e85680263efdd69178894
+  data.tar.gz: 70b7f897adb5ee1b4ead08b90517eb2d1d412dad
+SHA512:
+  metadata.gz: da824ddb560f2d64d476b3602d6e8c24c59f62ee62a367bf2b532813877d5151fdc45daae57ccc90aea77b3e9acf04054c1218e6fa5b60a4da284ba8ae9728f8
+  data.tar.gz: 640658471d76f8fa525f8057d6dc7a7159a56c093f498f165d1f570f9da6c0dce11f1e9c32ac09d0b016a2dcc2fd5d6a9575c58a481a3aae17a0ac9145b2173e

data/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Richard Morrisby
+
+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/README.txt

@@ -0,0 +1,43 @@
+This gem will attempt to generate code of a class of an object representing the contents of a Serialised-Object-Notation (SON) string (or file). E.g. it will generate code of a object's class from some JSON.
+
+The intention with this gem is to provide assistance with creating code that can translate JSON (or other SON) into a proper Object.
+
+If the SON looks to have a nested object structure (e.g. a Contact object looks to hold a PhoneNumber object) then multiple classes will be generated.
+
+Limitations :
+
+SON : will only process JSON
+Code : will only generate Ruby or Java
+
+Usage : require the gem, then invoke as follows : 
+
+ClassFromSON.generate_from_file :ruby, a_file.json
+
+or
+
+ClassFromSON.generate :ruby, my_json_string, :json
+
+
+Method parameter explanations :
+
+# Will generate classes from a SON file
+# Regardless of whether or not files are written, this will return an array of hashes; each hash represents a file, with two keys : :name for filename (without extension), and :contents for file contents
+#
+# dest_lang is symbol
+# file is filename & path
+# source_lang is symbol or nil (if nil, source language will be determined from the file extension)
+# make_file flag defaults to true; set to false if you do not want files to be created by this method
+# force_file flag is false; set to true if you wish to overwrite matching destination files (use with caution!)
+def ClassFromSON.generate_from_file(dest_lang, file, source_lang, make_file = true, force_file = false)
+
+
+
+# Will generate classes from a SON string
+# Regardless of whether or not files are written, this will return an array of hashes; each hash represents a file, with two keys : :name for filename (without extension), and :contents for file contents
+#
+# dest_lang is symbol
+# file is filename & path
+# source_lang is symbol
+# make_file flag defaults to true; set to false if you do not want files to be created by this method
+# force_file flag is false; set to true if you wish to overwrite matching destination files (use with caution!)
+def ClassFromSON.generate(dest_lang, source, source_lang, make_file = true, force_file = false)

data/build.rb

@@ -0,0 +1,51 @@
+# Simple build script
+# Deletes the existing gem file (if present)
+# Uninstalls the gem
+# Builds the gem
+# Installs the new gem
+
+# Note : when calling system (or backticks, etc.) th enew process starts at the system default, not the current working directory.
+# Therefore we need to use a syntax of : system "cd #{gem_dir} && #{i_cmd}"
+
+# Run from this directory!
+
+gem_dir = Dir.getwd
+
+# Delete existing .gem files in the dir
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+
+gemfiles.each do |q| 
+	File.delete q
+	puts "Deleted #{q}"
+end
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+raise "Gem has not been deleted" unless gemfiles.size == 0
+
+# Uninstall, build, install
+gemspecs = Dir.entries(gem_dir).collect {|q| q if q =~ /.gemspec$/}.compact
+
+raise "Did not find a .gemspec in #{gem_dir}" if gemspecs.size < 1
+raise "Found more than one .gemspec in #{gem_dir}" if gemspecs.size > 1
+
+gemspec = gemspecs[0]
+
+gemname = File.basename(gemspec, File.extname(gemspec))
+
+u_cmd = "gem uninstall #{gemname}"
+system u_cmd
+
+b_cmd = "gem build #{gemspec}"
+system "cd #{gem_dir} && #{b_cmd}"
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+raise "Gem was not built" unless gemfiles.size == 1
+
+gemfile = gemfiles[0]
+raise "Gem file is not for the expected gem, expected a #{gemname} gem but found #{gemfile}" unless gemfile =~ /^#{gemname}/
+
+i_cmd = "gem install #{gemfile}"
+system "cd #{gem_dir} && #{i_cmd}"
+
+puts "Gem #{gemname} built & installed"

data/class_from_son.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name        = 'class_from_son'
+  s.version     = '0.1.0'
+  s.licenses    = ['MIT']
+  s.summary     = "Generates classes from SON (e.g. JSON)"
+  s.description = "This gem will attempt to generate code of a class of an object representing the contents of a Serialised-Object-Notation (SON) string (or file). E.g. it will generate code of a object's class from some JSON."
+  s.authors     = ["Richard Morrisby"]
+  s.email       = 'rmorrisby@gmail.com'
+  s.files       = ["lib/class_from_SON.rb"]
+  s.homepage    = 'https://rubygems.org/gems/class_from_son'
+  s.required_ruby_version = '>=1.9'
+  s.files = Dir['**/**']
+  s.test_files = Dir["test/test*.rb"]
+  s.has_rdoc = true
+end

data/lib/class_from_SON.rb

@@ -0,0 +1,413 @@
+require "json"
+require "more-ruby"
+
+# A utility to convert an input file of string-object notation, e.g. JSON, XML, YAML, and generate code that looks like a class of your desired language
+
+class ClassFromSON
+
+	@@target_languages = [:java, :ruby]
+	@@input_modes = [:json]
+
+	def error(message)
+		puts "ERROR : #{message}"
+	end
+
+	def error_and_exit(message)
+		puts "ERROR : #{message}"
+		exit
+	end
+
+	def self.error_and_exit(message)
+		puts "ERROR : #{message}"
+		exit
+	end
+
+	def warn(message)
+		puts "WARN : #{message}"
+	end
+
+	def convert_ruby_type_to_type(type, value_types = [])
+		# puts "#{__method__} called with type '#{type.inspect}', #{type.class}, #{value_types.inspect}"
+		# Because type is an instance of Class, we need to compare names, so convert to String
+		# Use .to_s instead of .name to cope with custom types (i.e. types that are themselves new classes to be generated)
+		case type.to_s
+		when "Fixnum", "Integer"
+			converted = convert_fixnum_to_type
+		when "Float"
+			converted = convert_float_to_type
+		when "String"
+			converted = convert_string_to_type
+		when "TrueClass", "FalseClass"
+			converted = convert_boolean_to_type
+		when "Array"
+			converted = convert_array_to_type(value_types)
+		when "Hash"
+			converted = convert_hash_to_type(value_types)
+		when "NilClass" # default nil to String
+			converted = convert_string_to_type
+		else
+			converted = convert_custom_class_type(type)
+		end
+		# puts "Converted '#{type.inspect}' to #{converted}"
+		converted
+	end
+
+	# Translate "Fixnum" into the desired output language
+	def convert_fixnum_to_type
+		case @language
+		when :java
+			return "int"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Translate "Fixnum" into the desired output language
+	def convert_float_to_type
+		case @language
+		when :java
+			return "float"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Translate "Fixnum" into the desired output language
+	def convert_boolean_to_type
+		case @language
+		when :java
+			return "boolean"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Translate "String" into the desired output language
+	def convert_string_to_type
+		case @language
+		when :java
+			return "String"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Translate "Array" into the desired output language
+	# Also needs the 'value types', i.e. what type is this array? A list of strings? A list of ints?
+	def convert_array_to_type(value_types)
+		error_and_exit "Detected an array, but could not determine the type of its children; found #{value_types.size} possibilities" unless value_types.size == 1
+		case @language
+		when :java
+			return "List<#{convert_ruby_type_to_type(value_types[0])}>"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Translate "Hash" into the desired output language
+	# Also needs the 'value types', i.e. what type is this hash? A map of strings to booleans? A map of ints to strings?
+	def convert_hash_to_type(value_types)
+		error_and_exit "Detected a hash, but could not determine the type of its keys and values; found #{value_types.size} possibilities" unless value_types.size == 2
+		case @language
+		when :java
+			return "HashMap<#{convert_ruby_type_to_type(value_types[0])}, #{convert_ruby_type_to_type(value_types[1])}>"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Returns code representing the start of the class
+	def convert_custom_class_type(type)
+		case @language
+		when :java, :ruby
+			return type.capitalize_first_letter_only
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	def generate_top_level_name
+		case @language
+		when :java
+			return "generatedFrom#{@mode.capitalize}"
+		when :ruby
+			return "generated_from_#{@mode}"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Returns an appropriately-formatted classname for the given name
+	def generate_classname(name)
+		case @language
+		when :java, :ruby
+			return name.capitalize_first_letter_only
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Returns an appropriately-formatted filename for the given name
+	def generate_filename(name)
+		case @language
+		when :java
+			return name.capitalize_first_letter_only + @extension
+		when :ruby
+			return name.downcase + @extension # TODO convert camelcase to underbarised case
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	def set_file_extension_for_language
+		case @language
+		when :java
+			@extension = ".java"
+		when :ruby
+			@extension = ".rb"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Returns code representing the start of the class
+	def generate_class_start(name)
+		case @language
+		when :java
+			start = "public class #{convert_custom_class_type(name)} {"
+		when :ruby
+			start = "class #{convert_custom_class_type(name)}"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+		start
+	end
+
+	# Returns code representing the end of the class
+	def generate_class_end
+		case @language
+		when :java
+			class_end = "}"
+		when :ruby 
+			class_end = "end"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+		class_end
+	end
+
+	def generate_getter_and_setter(type, name)
+		lines = []
+		case @language
+		when :java
+			class_name = convert_custom_class_type(name)
+			lines << "\t"
+			lines << "\tpublic #{type} get#{class_name}() {"
+			lines << "\t\treturn #{name};"
+			lines << "\t}"
+			lines << "\t"
+			lines << "\tpublic void set#{class_name}(#{type} #{name}) {"		
+			lines << "\t\tthis.#{name} = #{name};"
+			lines << "\t}"
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+		lines
+	end
+
+	# Returns code representing each of the supplied attributes
+	def generate_code_from_attributes(attributes)
+		case @language
+		when :java
+			return generate_java_code_from_attributes(attributes)
+		when :ruby
+			return generate_ruby_code_from_attributes(attributes)
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
+		end
+	end
+
+	# Returns Java code representing each of the supplied attributes
+	def generate_java_code_from_attributes(attributes)
+		code = []
+		# Instance variables
+		attributes.each do |att|
+			code << "\tpublic #{convert_ruby_type_to_type(att[:type], att[:value_types])} #{att[:name]};"
+		end
+
+		#TODO constructor
+
+		# Getters & setters
+		attributes.each do |att|
+			code << generate_getter_and_setter(convert_ruby_type_to_type(att[:type], att[:value_types]), att[:name])
+		end
+		code
+	end
+
+	# Returns Ruby code representing each of the supplied attributes
+	def generate_ruby_code_from_attributes(attributes)
+		code = []
+		names = []
+		attributes.each {|att| names << att[:name]}
+
+		# Instance variables
+		names.each do |name|
+			code << "\tattr_accessor #{name.to_sym.inspect}"
+		end
+		code << "" # An empty string is enough to trigger a newline
+
+		# Constructor
+		code << "\tdef initialize(#{names.join(", ")})"
+		names.each do |name|
+			code << "\t\t@#{name} = #{name}"
+		end
+		code << "\tend"
+
+		code
+	end
+
+	# From the supplied hash, generates code representing a class in the desired language (as a string)
+	# Returns an array of hashes; each hash represents a file, with two keys : :name for filename (without extension), and :contents for file contents
+	def generate_output_classes(hash, top_level_classname = nil)
+		classname = generate_classname(top_level_classname)
+		filename = generate_filename(classname)
+		files = []
+		this_file = {:name => classname, :name_with_ext => filename}
+		lines = []
+		lines << generate_class_start(classname)
+		attributes = [] # array of hashes; keys => :name, :type, :value_types # :type, :value_types ([]) are initially kept as Ruby class names
+
+		hash.each_pair do |k, v|
+			attribute = {:name => k}
+			if v.class == Array
+				attribute[:type] = Array
+				if v[0].class == Hash
+					new_files = generate_output_classes(v[0], k)
+					attribute[:value_types] = [new_files[0][:name]]
+					files += new_files
+				else
+					# Array only contains primitives, not objects				
+					attribute[:value_types] = [v[0].class]
+				end			
+			elsif v.class == Hash
+				new_files = generate_output_classes(v, k)
+				attribute[:type] = new_files[0][:name]
+				files += new_files
+			else
+				attribute[:type] = v.class
+			end
+			attributes << attribute
+		end
+
+		lines << generate_code_from_attributes(attributes)
+		lines << generate_class_end
+		lines.flatten!
+		this_file[:contents] = lines.join("\n")
+		files.insert(0, this_file)
+		files
+	end
+
+	###################################################################################################
+	# The Generator
+	###################################################################################################
+
+	# Will generate classes from a SON file
+	# Regardless of whether or not files are written, this will return an array of hashes; each hash represents a file, with two keys : :name for filename (without extension), and :contents for file contents
+	#
+	# dest_lang is symbol
+	# file is filename & path
+	# source_lang is symbol or nil (if nil, source language will be determined from the file extension)
+	# make_file flag defaults to true; set to false if you do not want files to be created by this method
+	# force_file flag is false; set to true if you wish to overwrite matching destination files (use with caution!)
+	def ClassFromSON.generate_from_file(dest_lang, file, source_lang = nil, make_file = true, force_file = false)
+
+		error_and_exit "Could not locate file #{file}" unless File.exists?(file)
+
+		source_lang ||= File.extname(file).gsub(".", "")
+		source = File.readlines(file).join
+		ClassFromSON.generate(dest_lang, source, source_lang, make_file, force_file)
+
+		# o = ClassFromSON.new
+		# o.generate(dest_lang, source, source_lang, make_file)
+	end
+
+	# Will generate classes from a SON string
+	# Regardless of whether or not files are written, this will return an array of hashes; each hash represents a file, with two keys : :name for filename (without extension), and :contents for file contents
+	#
+	# dest_lang is symbol
+	# file is filename & path
+	# source_lang is symbol
+	# make_file flag defaults to true; set to false if you do not want files to be created by this method
+	# force_file flag is false; set to true if you wish to overwrite matching destination files (use with caution!)
+	def ClassFromSON.generate(dest_lang, source, source_lang, make_file = true, force_file = false)
+		o = ClassFromSON.new
+		o.generate(dest_lang, source, source_lang, make_file, force_file)
+	end
+
+	# Will generate classes from a SON string. 
+	# Regardless of whether or not files are written, this will return an array of hashes; each hash represents a file, with two keys : :name for filename (without extension), and :contents for file contents
+	#
+	# dest_lang is symbol
+	# file is filename & path
+	# source_lang is symbol
+	# make_file flag defaults to true; set to false if you do not want files to be created by this method
+	# force_file flag is false; set to true if you wish to overwrite matching destination files (use with caution!)
+	def generate(dest_lang, source, source_lang, make_file = true, force_file = false)
+
+		error_and_exit "Please supply first argument as a Symbol" unless dest_lang.class == Symbol
+
+		@language = dest_lang
+		if @@target_languages.include?(@language)
+			# may proceed
+			# TODO other target languages, e.g. C#, Python
+		else
+			error_and_exit "Cannot generate language #{@language}; can only generate #{@@target_languages.join(", ")}"
+		end
+		@extension = set_file_extension_for_language
+
+		@mode = source_lang.to_sym
+		if @@input_modes.include?(@mode)
+			# may proceed
+		else
+			error_and_exit "Cannot parse input language #{@mode}; can only parse #{@@input_modes.join(", ")}"
+		end
+
+		case @mode
+		when :json
+			hash = JSON.parse(source)
+			# TODO other input languages, e.g. XML, YAML
+		else
+			error_and_exit "Cannot parse mode #{@mode}"
+		end
+
+		# If we have read in an array instead of a hash, then take the first element of the array
+		# This assumes that each element in this top-level array has the same structure, which is reasonable
+		if hash.class == Array && hash.size > 0
+			hash = hash.shift
+		end
+
+		error_and_exit "Input file did not have a hash / map of key-value pairs; could not parse" unless hash.class == Hash
+
+		error_and_exit "Input file hash / map was empty" if hash.empty?
+
+		top_level_classname = generate_top_level_name
+		output_classes = generate_output_classes(hash, top_level_classname).flatten # returns an array
+
+		if make_file
+			output_classes.each do |out|
+				name = out[:name_with_ext]
+				contents = out[:contents]
+				unless force_file
+					error_and_exit "Want to generate output file #{name}, but that file already exists" if File.exists?(name)
+				end
+				File.open(name, "w+") do |f|
+					f.puts contents
+				end
+				puts "Wrote out file #{name}"
+			end
+
+			puts "Please inspect generated code files and adjust names and types accordingly"
+		end
+		output_classes
+	end
+end

data/test/Address.java

@@ -0,0 +1,38 @@
+public class Address {
+	public String streetAddress;
+	public String city;
+	public String state;
+	public String postalCode;
+	
+	public String getStreetAddress() {
+		return streetAddress;
+	}
+	
+	public void setStreetAddress(String streetAddress) {
+		this.streetAddress = streetAddress;
+	}
+	
+	public String getCity() {
+		return city;
+	}
+	
+	public void setCity(String city) {
+		this.city = city;
+	}
+	
+	public String getState() {
+		return state;
+	}
+	
+	public void setState(String state) {
+		this.state = state;
+	}
+	
+	public String getPostalCode() {
+		return postalCode;
+	}
+	
+	public void setPostalCode(String postalCode) {
+		this.postalCode = postalCode;
+	}
+}

data/test/GeneratedFromJson.java

@@ -0,0 +1,74 @@
+public class GeneratedFromJson {
+	public String firstName;
+	public String lastName;
+	public boolean isAlive;
+	public int age;
+	public Address address;
+	public List<PhoneNumbers> phoneNumbers;
+	public List<String> children;
+	public String spouse;
+	
+	public String getFirstName() {
+		return firstName;
+	}
+	
+	public void setFirstName(String firstName) {
+		this.firstName = firstName;
+	}
+	
+	public String getLastName() {
+		return lastName;
+	}
+	
+	public void setLastName(String lastName) {
+		this.lastName = lastName;
+	}
+	
+	public boolean getIsAlive() {
+		return isAlive;
+	}
+	
+	public void setIsAlive(boolean isAlive) {
+		this.isAlive = isAlive;
+	}
+	
+	public int getAge() {
+		return age;
+	}
+	
+	public void setAge(int age) {
+		this.age = age;
+	}
+	
+	public Address getAddress() {
+		return address;
+	}
+	
+	public void setAddress(Address address) {
+		this.address = address;
+	}
+	
+	public List<PhoneNumbers> getPhoneNumbers() {
+		return phoneNumbers;
+	}
+	
+	public void setPhoneNumbers(List<PhoneNumbers> phoneNumbers) {
+		this.phoneNumbers = phoneNumbers;
+	}
+	
+	public List<String> getChildren() {
+		return children;
+	}
+	
+	public void setChildren(List<String> children) {
+		this.children = children;
+	}
+	
+	public String getSpouse() {
+		return spouse;
+	}
+	
+	public void setSpouse(String spouse) {
+		this.spouse = spouse;
+	}
+}

data/test/PhoneNumbers.java

@@ -0,0 +1,20 @@
+public class PhoneNumbers {
+	public String type;
+	public String number;
+	
+	public String getType() {
+		return type;
+	}
+	
+	public void setType(String type) {
+		this.type = type;
+	}
+	
+	public String getNumber() {
+		return number;
+	}
+	
+	public void setNumber(String number) {
+		this.number = number;
+	}
+}

data/test/address.rb

@@ -0,0 +1,13 @@
+class Address
+	attr_accessor :streetAddress
+	attr_accessor :city
+	attr_accessor :state
+	attr_accessor :postalCode
+
+	def initialize(streetAddress, city, state, postalCode)
+		@streetAddress = streetAddress
+		@city = city
+		@state = state
+		@postalCode = postalCode
+	end
+end

data/test/generated_from_json.rb

@@ -0,0 +1,21 @@
+class Generated_from_json
+	attr_accessor :firstName
+	attr_accessor :lastName
+	attr_accessor :isAlive
+	attr_accessor :age
+	attr_accessor :address
+	attr_accessor :phoneNumbers
+	attr_accessor :children
+	attr_accessor :spouse
+
+	def initialize(firstName, lastName, isAlive, age, address, phoneNumbers, children, spouse)
+		@firstName = firstName
+		@lastName = lastName
+		@isAlive = isAlive
+		@age = age
+		@address = address
+		@phoneNumbers = phoneNumbers
+		@children = children
+		@spouse = spouse
+	end
+end

data/test/phonenumbers.rb

@@ -0,0 +1,9 @@
+class PhoneNumbers
+	attr_accessor :type
+	attr_accessor :number
+
+	def initialize(type, number)
+		@type = type
+		@number = number
+	end
+end

data/test/test_class_from_son.rb

@@ -0,0 +1,73 @@
+require "test/unit"
+require_relative "../lib/class_from_son"
+
+class TestEx < Test::Unit::TestCase
+
+    def switch_dir
+        # Change this to more easily find the test files
+        @previous_wd ||= Dir.getwd # Preserve the old wd so we can switch back to it after the test
+        Dir.chdir File.expand_path(File.dirname(__FILE__))    
+    end
+
+    # Switch to the same directory as this unit-test file
+    def setup
+        switch_dir
+    end
+
+	def test_class_from_json_to_ruby
+		json = File.readlines("testjson.json").join
+		
+		address_filename = "address.rb"
+		top_level_filename = "generated_from_json.rb"
+		phonenumbers_filename = "phonenumbers.rb"
+
+		expected_address = File.readlines(address_filename).join.chomp # trim off any trailing whitespace (irrelevent for this test)
+		expected_example = File.readlines(top_level_filename).join.chomp # trim off any trailing whitespace (irrelevent for this test)
+		expected_phonenumbers = File.readlines(phonenumbers_filename).join.chomp # trim off any trailing whitespace (irrelevent for this test)
+		
+		generated = nil
+		assert_nothing_raised("ClassFromSON.generate exited with an error") { generated = ClassFromSON.generate(:ruby, json, :json, false) }
+
+		assert_equal(3, generated.size, "Failed to correctly generate all Ruby classes from JSON")
+
+		assert_equal(top_level_filename, generated[0][:name_with_ext], "Failed to correctly generate top-level generated_from_json example filename")
+		assert_equal(address_filename, generated[1][:name_with_ext], "Failed to correctly generate address example filename")
+		assert_equal(phonenumbers_filename, generated[2][:name_with_ext], "Failed to correctly generate phonenumbers example filename")
+
+		assert_equal(expected_example, generated[0][:contents], "Failed to correctly generate top-level GeneratedFromJson example Ruby class from JSON")
+		assert_equal(expected_address, generated[1][:contents], "Failed to correctly generate Address example Ruby class from JSON")
+		assert_equal(expected_phonenumbers, generated[2][:contents], "Failed to correctly generate PhoneNumbers example Ruby class from JSON")
+	end
+
+
+	def test_class_from_json_to_java
+		json = File.readlines("testjson.json").join
+		
+		address_filename = "Address.java"
+		top_level_filename = "GeneratedFromJson.java"
+		phonenumbers_filename = "PhoneNumbers.java"
+
+		expected_address = File.readlines(address_filename).join.chomp # trim off any trailing whitespace (irrelevent for this test)
+		expected_example = File.readlines(top_level_filename).join.chomp # trim off any trailing whitespace (irrelevent for this test)
+		expected_phonenumbers = File.readlines(phonenumbers_filename).join.chomp # trim off any trailing whitespace (irrelevent for this test)
+		
+		generated = nil
+		assert_nothing_raised("ClassFromSON.generate exited with an error") { generated = ClassFromSON.generate(:java, json, :json, false) }
+
+		assert_equal(3, generated.size, "Failed to correctly generate all Java classes from JSON")
+
+		assert_equal(top_level_filename, generated[0][:name_with_ext], "Failed to correctly generate top-level GeneratedFromJson example filename")
+		assert_equal(address_filename, generated[1][:name_with_ext], "Failed to correctly generate Address example filename")
+		assert_equal(phonenumbers_filename, generated[2][:name_with_ext], "Failed to correctly generate PhoneNumbers example filename")
+
+		assert_equal(expected_example, generated[0][:contents], "Failed to correctly generate top-level GeneratedFromJson example Java class from JSON")
+		assert_equal(expected_address, generated[1][:contents], "Failed to correctly generate Address example Java class from JSON")
+		assert_equal(expected_phonenumbers, generated[2][:contents], "Failed to correctly generate PhoneNumbers example Java class from JSON")
+	end
+
+
+    # Restore the working directory to what it was previously
+    def teardown
+        Dir.chdir @previous_wd # restore the working directory to what it was previously
+    end
+end

data/test/testjson.json

@@ -0,0 +1,28 @@
+{
+  "firstName": "John",
+  "lastName": "Smith",
+  "isAlive": true,
+  "age": 25,
+  "address": {
+    "streetAddress": "21 2nd Street",
+    "city": "New York",
+    "state": "NY",
+    "postalCode": "10021-3100"
+  },
+  "phoneNumbers": [
+    {
+      "type": "home",
+      "number": "212 555-1234"
+    },
+    {
+      "type": "office",
+      "number": "646 555-4567"
+    },
+    {
+      "type": "mobile",
+      "number": "123 456-7890"
+    }
+  ],
+  "children": [],
+  "spouse": null
+}

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: class_from_son
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Richard Morrisby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-03 00:00:00.000000000 Z
+dependencies: []
+description: This gem will attempt to generate code of a class of an object representing
+  the contents of a Serialised-Object-Notation (SON) string (or file). E.g. it will
+  generate code of a object's class from some JSON.
+email: rmorrisby@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENCE.txt
+- README.txt
+- build.rb
+- class_from_son.gemspec
+- lib/class_from_SON.rb
+- test/Address.java
+- test/GeneratedFromJson.java
+- test/PhoneNumbers.java
+- test/address.rb
+- test/generated_from_json.rb
+- test/phonenumbers.rb
+- test/test_class_from_son.rb
+- test/testjson.json
+homepage: https://rubygems.org/gems/class_from_son
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Generates classes from SON (e.g. JSON)
+test_files:
+- test/test_class_from_son.rb