class_from_son 0.1.6 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abf5d4e89cc9bf59334246eb70e5f81ee9e8dab9b48e7585879ad3c81013d18c
-  data.tar.gz: e1810cf3ee2f162217dce26e53de3c7b30d0e3b6a141a969b7404aad221e6f42
+  metadata.gz: 86fd5ffbcbad4d75f5ba1415762ef98380c2752c0fdd523e5b903cda8fedcf35
+  data.tar.gz: f89cad4aad4fee289a266b774080a06db9165145e5a26fb852be1f2f6a1f647d
 SHA512:
-  metadata.gz: c758b0ebf50b308cc29bb7a122346e39e0b185b7144afec35942387a4a4323d8ca369635a5167f3ee3891955ee8ef3352443e2c247c39ec0a9346d7c75013a3b
-  data.tar.gz: e148c2ff366ea22b46cbc3050604f7bf3cf9f58bbb1b79bea8b1ba82ea5949acc9d328aba65ec42e030092f0ee750708fe4f39106ee7d659cad5743922de0323
+  metadata.gz: 160a134313363eb41fb3ba88bd54272c6d8c127c61f6201266689df24a2db82c5a5919c14d0e9dde81946eaf9837523ad16b6a040f9b4a80177dc676f24df420
+  data.tar.gz: 52647cc8256cb44ec638a43850c4a009bf09fdcfda56440f00bd47262f1e4e499b8699fd8b195ce3e09c2a2fe5c5c65ebcc3cf91b19320216a920f0f35831293

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
@@ -285,21 +295,94 @@ 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 << "    # @#{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
+	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}, :symbolize_names => true))"
+			# TODO other input languages, e.g. XML, YAML
+		end
+		code << "  end"
+		
+		# to_hash method
+		code << ""
+		code << "  def to_hash"
+		code << "    h = {}"
 		names.each do |name|
-			code << "\t\t@#{name} = #{name}"
+			code << "    h[:#{name}] = @#{name}"
 		end
-		code << "\tend"
+		code << "    h"
+		code << "  end"
 
+		# to_SON method & alias
+		code << ""
+		code << "  def to_#{@mode}"
+		case @mode
+		when :json
+			code << "    JSON.generate(to_hash)"
+			# TODO other input languages, e.g. XML, YAML
+		end
+		code << "  end"
+		case @mode
+		when :json
+			code << "  alias to_s to_json"
+			# TODO other input languages, e.g. XML, YAML
+		end
 		code
 	end
 
@@ -337,6 +420,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")
@@ -356,13 +440,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)
@@ -376,9 +463,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. 
@@ -389,7 +479,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
 
@@ -434,16 +527,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.6
+  version: 0.2.2
 platform: ruby
 authors:
 - Richard Morrisby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-20 00:00:00.000000000 Z
+date: 2021-07-07 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: {}