class_from_son 0.1.5 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f413bc7bc0f742bf3ac5f2cee734a668edf7d53f0a2e10718f852fdcce4cc901
-  data.tar.gz: 87ca04dc961b84b5fdb1779643e52d548e6c4f84899870c9f297802d498ce196
+  metadata.gz: 7faa342b7ee967052d435004f43ce42c65da00131023013fc42309ce6a9e8808
+  data.tar.gz: 356699a2d3b8f2df84da9010cc03fa33c779e3ca1bb6dbdfa11cfbb2568487aa
 SHA512:
-  metadata.gz: aeff2562e7f122804a323348eebc4cfa6a3cadb89e3e5f4a9bb755d62e0f9890b07268fb483b71f4b245bf575300de88599903fdeb8c7ff4906bff96323fc936
-  data.tar.gz: 941bb7fbd059e1634d5dfd6fd5628b7e913c99883610b4e7a30c13ea29bd8d2610f766bd818ce53fee931e3e19167d1b61163fab9234151bdd09cc102664e15b
+  metadata.gz: 2bbd9f6ca9246dc4b273a037e322bf4da6ce69258c120fc56f5ba2240b4a5047020867ed16cd86833c2a7dd4806855174acea4cabcb272e25a4527d821042e5f
+  data.tar.gz: 1b7967cffab7c886230b0d726260516441dfaf320d7238d50b201d2b655340d1446396ec9eb57b477b7a5122fd6c842954baf20a89b65b6934182e78f2bfdd62

data/README.md

@@ -31,6 +31,12 @@ or
 ruby -e "require 'class_from_son'; ClassFromSON.generate :ruby, my_json_string, :json"
 ```
 
+Advanced use :
+
+```
+ruby -e "require 'class_from_son'; ClassFromSON.generate :ruby, my_json_string, :json, true, false, true, '../write/files/somewhere/else'"
+```
+
 Method parameter explanations :
 
 ```
@@ -42,7 +48,10 @@ Method parameter explanations :
 # 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)
+# lenient_mode flag is true; if the SON contains different objects with the same name (e.g. "data") then these will be treated
+#    as different objects with a _1, _2, etc. suffix. If this flag is false and these different objects are present, then errors will occur
+# custom_file_path is nil; set to an absoulte or relative path to have the new files be written to that location
+def ClassFromSON.generate_from_file(dest_lang, file, source_lang = nil, make_file = true, force_file = false, lenient_mode = true, custom_file_path = nil)
 ```
 
 ```
@@ -54,5 +63,8 @@ def ClassFromSON.generate_from_file(dest_lang, file, source_lang, make_file = tr
 # 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)
+# lenient_mode flag is true; if the SON contains different objects with the same name (e.g. "data") then these will be treated
+#    as different objects with a _1, _2, etc. suffix. If this flag is false and these different objects are present, then errors will occur
+# custom_file_path is nil; set to an absoulte or relative path to have the new files be written to that location
+def ClassFromSON.generate(dest_lang, source, source_lang, make_file = true, force_file = false, lenient_mode = true, custom_file_path = nil)
 ```

data/lib/class_from_SON.rb

@@ -172,15 +172,16 @@ class ClassFromSON
 
 	# Returns code representing the start of the class
 	def generate_class_start(name)
+		# TODO make this more readable
 		case @language
-		when :java, :java_lombok
+		when :java
 			start = <<-START
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 
 public class #{convert_custom_class_type(name)} {
 START
-		when :java_lombok # TODO
+		when :java_lombok
 			start = <<-START
 
 import com.fasterxml.jackson.annotation.JsonProperty;
@@ -199,7 +200,16 @@ import lombok.Setter;
 public class #{convert_custom_class_type(name)} {
 START
 		when :ruby
-			start = "class #{convert_custom_class_type(name)}"
+			case @mode
+			when :json
+			start = <<-START
+require 'json'
+
+class #{convert_custom_class_type(name)}
+START
+			else 
+				error_and_exit "Cannot parse mode #{@mode}"
+			end
 		else 
 			error_and_exit "Could not convert to output language #{@language}"
 		end
@@ -225,13 +235,17 @@ START
 		when :java_lombok
 			# do nothing - Lombok's raison d'etre is to avoid getters & setters
 		when :java
-			class_name = convert_custom_class_type(name)
+			# This is safe even if the name is already in snakecase
+			field_name_for_getter = name.snakecase.pascalcase
+
+			name = name.camelcase if name.include? "_"
+				
 			lines << "\t"
-			lines << "\tpublic #{type} get#{class_name}() {"
+			lines << "\tpublic #{type} get#{field_name_for_getter}() {"
 			lines << "\t\treturn #{name};"
 			lines << "\t}"
 			lines << "\t"
-			lines << "\tpublic void set#{class_name}(#{type} #{name}) {"		
+			lines << "\tpublic void set#{field_name_for_getter}(#{type} #{name}) {"		
 			lines << "\t\tthis.#{name} = #{name};"
 			lines << "\t}"
 		else 
@@ -262,6 +276,7 @@ START
 				camelcase_name = att[:name].camelcase
 				code << "\t@JsonProperty(\"#{snakecase_name}\")"
 				code << "\tprivate #{convert_ruby_type_to_type(att[:type], att[:value_types])} #{camelcase_name};"
+				code << "" # add a new line so that fields are separated & easier to read
 			else 
 				code << "\tprivate #{convert_ruby_type_to_type(att[:type], att[:value_types])} #{att[:name]};"
 			end
@@ -280,21 +295,83 @@ START
 	def generate_ruby_code_from_attributes(attributes)
 		code = []
 		names = []
-		attributes.each {|att| names << att[:name]}
+		attributes.each {|att| names << att[:name].snakecase}
 
 		# Instance variables
 		names.each do |name|
-			code << "\tattr_accessor #{name.to_sym.inspect}"
+			code << "  attr_accessor #{name.to_sym.inspect}"
 		end
 		code << "" # An empty string is enough to trigger a newline
 
 		# Constructor
-		code << "\tdef initialize(#{names.join(", ")})"
+		# This is deliberately commented out, in favour of self.from_hash
+		code << "  # Using self.from_hash(hash) is usually better, but this code is here in case you prefer this style of constructor"
+		code << "  # def initialize(#{names.join(", ")})"
 		names.each do |name|
-			code << "\t\t@#{name} = #{name}"
+			code << "    # @#{name} = #{name}"
+		end
+		code << "  # end"
+		code
+	end
+
+	# Returns code for a from_SON and to_SON method
+	def generate_from_and_to_methods(classname, attributes)
+		case @language
+		when :java, :java_lombok
+			return generate_java_from_and_to_methods(classname, attributes)
+		when :ruby
+			return generate_ruby_from_and_to_methods(classname, attributes)
+		else 
+			error_and_exit "Could not convert to output language #{@language}"
 		end
-		code << "\tend"
+	end
 
+	# Returns Java code for a from_SON and to_SON method
+	def generate_java_from_and_to_methods(classname, attributes)
+		code = []
+		# TODO
+		code
+	end
+
+	# Returns Ruby code for a from_SON and to_SON method
+	def generate_ruby_from_and_to_methods(classname, attributes)
+		code = []
+		names = []
+		attributes.each {|att| names << att[:name].snakecase}
+
+		# from_hash method
+		code << ""
+		code << "  def self.from_hash(h)"
+		code << "    o = self.new"
+		names.each do |name|
+			code << "    o.#{name} = h[:#{name}]"
+		end
+		code << "    o"
+		code << "  end"
+
+		# from_SON method
+		code << ""
+		code << "  def self.from_#{@mode}(#{@mode})"
+		case @mode
+		when :json
+			code << "    self.from_hash(JSON.parse(#{@mode}))"
+			# TODO other input languages, e.g. XML, YAML
+		end
+		code << "  end"
+		
+		# to_SON method
+		code << ""
+		code << "  def to_#{@mode}"
+		code << "    h = {}"
+		names.each do |name|
+			code << "    h[:#{name}] = @#{name}"
+		end
+		case @mode
+		when :json
+			code << "    JSON.generate(h)"
+			# TODO other input languages, e.g. XML, YAML
+		end
+		code << "  end"
 		code
 	end
 
@@ -332,6 +409,7 @@ START
 		end
 
 		lines << generate_code_from_attributes(attributes)
+		lines << generate_from_and_to_methods(classname, attributes)
 		lines << generate_class_end
 		lines.flatten!
 		this_file[:contents] = lines.join("\n")
@@ -351,13 +429,16 @@ START
 	# 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)
+	# lenient_mode flag is true; if the SON contains different objects with the same name (e.g. "data") then these will be treated
+	#    as different objects with a _1, _2, etc. suffix. If this flag is false and these different objects are present, then errors will occur
+	# custom_file_path is nil; set to an absoulte or relative path to have the new files be written to that location
+	def ClassFromSON.generate_from_file(dest_lang, file, source_lang = nil, make_file = true, force_file = false, lenient_mode = true, custom_file_path = nil)
 
 		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)
+		ClassFromSON.generate(dest_lang, source, source_lang, make_file, force_file, lenient_mode, custom_file_path)
 
 		# o = ClassFromSON.new
 		# o.generate(dest_lang, source, source_lang, make_file)
@@ -371,9 +452,12 @@ START
 	# 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)
+	# lenient_mode flag is true; if the SON contains different objects with the same name (e.g. "data") then these will be treated
+	#    as different objects with a _1, _2, etc. suffix. If this flag is false and these different objects are present, then errors will occur
+	# custom_file_path is nil; set to an absoulte or relative path to have the new files be written to that location
+	def ClassFromSON.generate(dest_lang, source, source_lang, make_file = true, force_file = false, lenient_mode = true, custom_file_path = nil)
 		o = ClassFromSON.new
-		o.generate(dest_lang, source, source_lang, make_file, force_file)
+		o.generate(dest_lang, source, source_lang, make_file, force_file, lenient_mode, custom_file_path)
 	end
 
 	# Will generate classes from a SON string. 
@@ -384,7 +468,10 @@ START
 	# 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)
+	# lenient_mode flag is true; if the SON contains different objects with the same name (e.g. "data") then these will be treated
+	#    as different objects with a _1, _2, etc. suffix. If this flag is false and these different objects are present, then errors will occur
+	# custom_file_path is nil; set to an absoulte or relative path to have the new files be written to that location
+	def generate(dest_lang, source, source_lang, make_file = true, force_file = false, lenient_mode = true, custom_file_path = nil)
 
 		error_and_exit "Please supply first argument as a Symbol" unless dest_lang.class == Symbol
 
@@ -429,16 +516,46 @@ START
 		top_level_classname = generate_top_level_name
 		output_classes = generate_output_classes(hash, top_level_classname).flatten # returns an array
 
+		# Set the directory that the files will be written into
+		if custom_file_path
+			# This caters for both absolute & relative file paths
+			file_path = File.absolute_path(custom_file_path)
+		else
+			file_path = Dir.getwd
+		end
+
+		# Track the names of the classes/files we have written so far
+		written_file_names = []
+
 		if make_file
 			output_classes.each do |out|
 				name = out[:name_with_ext]
+				# Check the name against the files we have already written
+				if written_file_names.include?(name)
+					if lenient_mode
+						# Let us increment the name, e.g. "data.rb" -> "data_1.rb", "data_2.rb", etc.
+						increment = 1
+						new_name = name.gsub(@extension, "_#{increment}#{@extension}")
+						while written_file_names.include?(new_name)
+							increment += 1
+							new_name = name.gsub(@extension, "_#{increment}#{@extension}")
+						end
+						name = new_name
+					else
+						message = "Want to generate output file #{name}, but a file with that name has already been written by this process. Your SON structure contains 2+ different classes with the same name"
+						error_and_exit(message) 
+					end
+				end
+
+				filename = file_path + File::SEPARATOR + name
 				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|
+				File.open(filename, "w+") do |f|
 					f.puts contents
 				end
+				written_file_names << name
 				puts "Wrote out file #{name}"
 			end
 

data/test/test_class_from_son.rb

@@ -19,7 +19,7 @@ class TestEx < Test::Unit::TestCase
 		
 		address_filename = "address.rb"
 		top_level_filename = "generated_from_json.rb"
-		phonenumbers_filename = "phonenumbers.rb"
+		phonenumbers_filename = "phone_numbers.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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: class_from_son
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.1
 platform: ruby
 authors:
 - Richard Morrisby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-20 00:00:00.000000000 Z
+date: 2021-07-06 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
@@ -22,7 +22,7 @@ files:
 - README.md
 - lib/class_from_SON.rb
 - test/test_class_from_son.rb
-homepage: https://rubygems.org/gems/class_from_son
+homepage: https://github.com/RMorrisby/class_from_son
 licenses:
 - MIT
 metadata: {}