petit-felix 0.1.5 → 0.1.7

data/lib/worker/pdf_writer.rb

@@ -1,6 +1,7 @@
 require "prawn"
 require 'fileutils'
 require "prawndown-ext"
+require "felix/file"
 require "worker/pdf_writer/column_box"
 require "worker/pdf_writer/bounding_box"
 
@@ -22,32 +23,43 @@ module PetitFelix
 			def add_font (type,
 									default_font: "default")
 
-					if @options.key?(type + "_font_normal")
+					if @options.key? "#{type}_font_normal"
 					
-						font_normal = type + "_font_normal"
-						font_italic = type + "_font_normal"
-						font_bold = type + "_font_normal"
-						font_bold_italic = type + "_font_normal"
+						font_normal = "#{type}_font_normal"
+						font_italic = "#{type}_font_normal"
+						font_bold = "#{type}_font_normal"
+						font_bold_italic = "#{type}_font_normal"
 						
-						if @options.key?(type + "_font_italic")
-							font_italic = type + "_font_italic"
+						if @options.key? "#{type}_font_italic"
+						
+							font_italic = "#{type}_font_italic"
+							
 						end
-						if @options.key?(type + "_font_bold")
-							font_bold = type + "_font_bold"
+						
+						if @options.key? "#{type}_font_bold"
+						
+							font_bold = "#{type}_font_bold"
+							
 						end
-						if @options.key?(type + "_font_bold_italic")
-							font_bold_italic = type + "_font_bold_italic"
+						
+						if @options.key? "#{type}_font_bold_italic"
+						
+							font_bold_italic = "#{type}_font_bold_italic"
+							
 						end
 					
 						font_families.update(type => {
+						
 							:normal => @options[font_normal],
 							:italic => @options[font_italic],
 							:bold => @options[font_bold],
 							:bold_italic => @options[font_bold_italic]
+							
 						})
 						
 					else
 						if font_families.key?(default_font)
+						
 							font_families.update(type => {
 								:normal => font_families[default_font][:normal],
 								:italic => font_families[default_font][:italic],
@@ -56,82 +68,37 @@ module PetitFelix
 							})
 							
 						else
+						
 							font_families.update(type => {
 								:normal => @options["font_normal"],
 								:italic => @options["font_italic"],
 								:bold => @options["font_bold"],
 								:bold_italic => @options["font_bold_italic"]
 							})
+							
 						end
 						
 					end
 			end
 		
 			def set_options metaoptions
+			
 				@options = metaoptions
+				
 			end
 		
 			def output
-				FileUtils.mkdir_p File.dirname(@options["output_dir"] + "/" + @options["output_file"])
-				render_file(@options["output_dir"] + "/" + @options["output_file"])
-			end
-			
-			
-    def start_new_page(options = {})
-      last_page = state.page
-      if last_page
-        last_page_size = last_page.size
-        last_page_layout = last_page.layout
-        last_page_margins = last_page.margins.dup
-      end
-
-      page_options = {
-        size: options[:size] || last_page_size,
-        layout: options[:layout] || last_page_layout,
-        margins: last_page_margins,
-      }
-      if last_page
-        if last_page.graphic_state
-          new_graphic_state = last_page.graphic_state.dup
-        end
-
-        # erase the color space so that it gets reset on new page for fussy
-        # pdf-readers
-        new_graphic_state&.color_space = {}
-
-        page_options[:graphic_state] = new_graphic_state
-      end
+				
+				fileedit = PetitFelix::FileManager.new
+				
+				file_output = fileedit.file_array_from_string(@options["output_dir"]) + [@options["output_file"]]
 
-      state.page = PDF::Core::Page.new(self, page_options)
+				file = File.join(file_output)
 
-      apply_margin_options(options)
-      generate_margin_box
-
-      # Reset the bounding box if the new page has different size or layout
-      if last_page && (last_page.size != state.page.size ||
-                       last_page.layout != state.page.layout)
-        @bounding_box = @margin_box
-      end
-
-      use_graphic_settings
-
-      unless options[:orphan]
-        state.insert_page(state.page, @page_number)
-        @page_number += 1
-
-        if @background
-          canvas do
-            image(@background, scale: @background_scale, at: bounds.top_left)
-          end
-        end
-        @y = @bounding_box.absolute_top
-
-        float do
-          state.on_page_create_action(self)
-        end
-      end
-      
-    end
+				FileUtils.mkdir_p File.dirname(file)
+				render_file(file)
+				
+			end
 		
 		end
 	end

data/lib/worker/template_pdf_writer.rb

@@ -4,7 +4,10 @@ require "prawndown-ext"
 require "felix/metadata"
 require "felix/error"
 require "worker/pdf_writer"
-require "worker/template_pdf_calls"
+require "worker/templater/methods"
+require "worker/templater/error"
+require "worker/templater/validation"
+require "worker/templater/font"
 require "eqn"
 
 ## Prawn PDF writer that inputs template files
@@ -14,49 +17,13 @@ module PetitFelix
 
 		class	TemplatePDFWriter < PetitFelix::Worker::DefaultPDFWriter
 			
-			# error count: 16
-			
-			ERROR_CODES = [
-				"OK",
-				"Malformed command list.",
-				"No command defined. Use \"com\" or \"command\" to define commands.",
-				"Command not found.",
-				"Stack overflow.",
-				"Template ID \"{{arg}}\" not found.",
-				"Template method \"{{arg}}\" not found.",
-				"\"{{arg}}\" argument not defined.",
-				"Expression \"{{arg}}\" does not result in boolean result.",
-				"Expression \"{{arg}}\" cannot be evaluated.",
-				"File \"{{arg}}\" not found.",
-				"Not a valid position.",
-				"\"at\" (Array) argument not defined.",
-				"\"{{arg}}\" is not an array.",
-				"Image \"{{arg}}\" not found.",
-				"Template file \"{{arg}}\" not found.",
-				"\"template\" option not defined. No template file can be loaded."
-			]
-			
-			SYMBOLIZE = [
-				:align,
-				:odd_align,
-				:even_align,
-				:valign,
-				:odd_valign,
-				:even_valign,
-				:direction,
-				:mode,
-				:style,
-				:overflow,
-				:rotate_around
-			]
-			
-			
 			# Highest a stack is allowed to be
 			MAX_STACK = 1024
 			
 			## Functions
 			
 			def init_values options, pdf
+			
 				@variables = {}
 			
 				@options = Marshal.load(Marshal.dump(options))
@@ -89,51 +56,22 @@ module PetitFelix
 				set_variables
 			end
 			
-			# Adds a font to the pdf document
-			def add_font font, font_name
-
-				if font.key?(:normal)
-				
-					if font.key?(:italic)
-						font[:italic] = font[:normal]
-					end
-					if font.key?(:bold)
-						font[:bold] = font[:normal]
-					end
-					if font.key?(:bold_italic)
-						font[:bold_italic] = font[:normal]
-					end
-					
-					font.keys.each do |key|
-						font[key] = replace_variable font[key]
-					end
-				
-					font_families.update(font_name => font)
-					
-				end
-						
-			end
-			
-			def add_fonts
-				font_families.clear
-				
-				fonts = Marshal.load(Marshal.dump(@fonts))
-			
-				fonts.keys.each do |font|
-					add_font fonts[font], font.to_s
-				end
-				
-			end
-			
 			def set_variables
+			
 				@metaoptions.keys.each do |key|
+				
 					@variables[key] = @metaoptions[key]
+					
 				end
 				
 				if @variables.key? :markdown_metadata
+				
 					@variables[:markdown_metadata].keys.each do |meta|
+					
 						@variables[meta] = @variables[:markdown_metadata][meta]
+						
 					end
+					
 				end
 				
 				## add additional functional stuff
@@ -150,17 +88,22 @@ module PetitFelix
 			def replace_variables args
 			
 				args.keys.each do |arg|
+				
 					if args[arg].instance_of? String
+					
 						args[arg] = replace_variable args[arg]
+						
 					end
 				end
 				
 				args
+				
 			end
 			
 			def replace_variable string
+			
 				@variables.keys.each do |key|
-					string = string.gsub("${" + key.to_s + "}", @variables[key].to_s)
+					string = string.gsub("${#{key}}", @variables[key].to_s)
 				end
 				
 				string
@@ -172,8 +115,11 @@ module PetitFelix
 			# Format: Array of objects where
 			# each object has command and set of args
 			def read_template
-				if @options.key?("template")
-					if File.file?(@options["template"])
+			
+				if @options.key? "template"
+				
+					if File.file? @options["template"]
+					
 						obj = JSON.parse(File.read(@options["template"]), symbolize_names: true)
 					
 						default_options = obj[:default_variables].transform_keys!(&:to_s)
@@ -184,12 +130,14 @@ module PetitFelix
 						
 						@fonts = {}
 						
-						@metaoptions = default_options.merge(@options)
+						@metaoptions = default_options.merge @options
 						
 						set_variables
 						
-						if obj.key?(:fonts)
+						if obj.key? :fonts
+						
 							@fonts = obj[:fonts]
+							
 						end
 						
 						add_fonts
@@ -199,17 +147,21 @@ module PetitFelix
 						}
 						
 						# Runs the main function as entry point of the template
-						@template_stack.push("main")
+						@template_stack.push "main"
 						result = execute_function "main", "main", self
 						
 						if result[0] != 0
+						
 							print_error result[0], result[1]
 						end
+						
 					else
+					
 						@error_param["arg"] = @options["template"].to_s
 						print_error 15, -1
 						
 					end
+					
 				else
 				
 					print_error 16, -1
@@ -221,18 +173,24 @@ module PetitFelix
 			
 				definition = nil
 
-				if !@template.key?(template_id)
+				if !@template.key? template_id
+				
 					@error_param["arg"] = template_id.to_s
 					# Fails because template ID not found.
 					return [5, -1]
+					
 				else
 				
-					if !@template[template_id].key?(function_id.to_sym )
+					if !@template[template_id].key? function_id.to_sym
+					
 						@error_param["arg"] = function_id.to_s
 						# Fails because template function ID not found.
 						return [6, -1]
+						
 					else
+					
 						definition = Marshal.load(Marshal.dump(@template[template_id][function_id.to_sym]))
+					
 					end
 					
 				end
@@ -241,7 +199,7 @@ module PetitFelix
 
 					counter = 0
 					
-					@counter_stack.push(counter)
+					@counter_stack.push counter
 					
 					for index in counter ... definition.size
 
@@ -252,50 +210,63 @@ module PetitFelix
 						
 						command = ""
 						
-						if line.key?(:cmd)
+						if line.key? :cmd
+						
 							command = line[:cmd].to_sym
+							
 						end
 						
-						if line.key?(:command)
+						if line.key? :command
+						
 							command = line[:command].to_sym
+							
 						end
 						
 						args = {
 							"LINE_NUMBER" => counter
 						}
 						
-						if line.key?(:args)
+						if line.key? :args
+						
 							args = line[:args]
+							
 						end
 						
 						begin
+						
 							args = replace_variables(args)
 							
 						rescue => error
+						
 							print "\n"
 							print error
 							print "\n"
 							print "Error rendering variables!\n"
+							
 						end
 						
 						if !command.empty?
 							
-							if COMMAND.keys.include?(command)
+							if COMMAND.keys.include? command
+							
 								@command_stack.push definition
 							
 								if @command_stack.count > 1024
 									# Failed because of stack overflow
 									return [4, counter]
+									
 								end
 
-								comm = COMMAND[command].call(obj, args)
+								comm = COMMAND[command].call obj, args
 
 								@counter_stack[-1] = counter
 								counter += 1
 
 								# something about command execution failed
 								if comm != 0
+								
 									return [comm, counter]
+									
 								end
 
 								@command_stack.pop
@@ -310,7 +281,6 @@ module PetitFelix
 							return [2, -1]
 						
 						end
-						
 					end
 					
 					@counter_stack.pop()
@@ -322,178 +292,6 @@ module PetitFelix
 
 				# Failed because malformed command list
 				return [1, -1]
-			end
-			
-			## Error display
-			
-			def error_replace_string error
-
-				@error_param.keys.each do |key|
-					error = error.gsub("{{"+ key +"}}", @error_param[key])
-				end
-		
-				error			
-			end
-			
-			def print_error error_code, line
-
-				if error_code > -1 && error_code < ERROR_CODES.count
-					@error_printer.print_err "Error reading template. " + error_replace_string(ERROR_CODES[error_code])
-				else
-					@error_printer.print_err "Error reading template. General template processing error occured."
-				end
-				
-				print "Error code: " + error_code.to_s
-				
-				print "\n\n"
-				print "Processing markdown file: " + @metaoptions["filename"]
-				print "\n\n"
-				
-				stack_rv = @command_stack.reverse
-
-				if line >= 0 && !stack_rv.empty?
-				
-					print "\n\nCurrent line:\n"
-					print stack_rv[0][line]
-
-					print "\n\nCurrent Stack:"
-					test_arr = *(0..[19,@command_stack.count-1].min)
-					test_arr.each do | i |
-						command_obj = stack_rv[i]
-
-						line_edit = command_obj[0..@counter_stack[i]+1]
-					
-						print "\n"
-						print "Line: (" + line_edit.count.to_s + "): "
-						print line_edit[-1]
-					end
-				end
-				
-				print "\n"
-				
-				return error_code
-			end
-			
-			## These methods validate parameters
-			
-			def args_has_string arg_name, args
-				if !args.key?(arg_name)
-					# text not defined
-					@error_param["arg"] = arg_name.to_s
-					return 7
-				end
-				
-				args[arg_name] = replace_variable args[arg_name].to_s
-				
-				return 0
-			end
-			
-			def args_has_int arg_name, args
-				if !args.key?(arg_name)
-					# text not defined
-					@error_param["arg"] = arg_name.to_s
-					return 7
-				end
-
-				if args[arg_name].instance_of? String
-					args[arg_name] = Eqn::Calculator.calc(replace_variable args[arg_name]).to_i
-				end
-				return 0
-			end
-			
-			def args_has_float arg_name, args
-
-				if !args.key?(arg_name)
-					# text not defined
-					@error_param["arg"] = arg_name.to_s
-					return 7
-				end
-				
-				args[arg_name] = Eqn::Calculator.calc(replace_variable args[arg_name]).to_f
-				
-				return 0
-			end
-			
-			def args_has_arr (arg_name, args, type, options = {})
-			
-				if !args.key?(arg_name)
-					# text not defined
-					@error_param["arg"] = arg_name.to_s
-					return 7
-				end
-				
-				if args[arg_name].instance_of? String
-					begin
-						set_variables
-
-						test = replace_variable args[arg_name]
-						
-						args[arg_name] = JSON.parse(test)
-
-					rescue => error
-						print "\nError parsing array: " + args[arg_name] + "\n"
-						print error
-					
-					end
-					
-				end
-				
-				if args[arg_name].instance_of? Array	
-						if type == :float
-							args[arg_name].map! {|item| Eqn::Calculator.calc(replace_variable item.to_s).to_f }
-						elsif type == :int
-							args[arg_name].map! {|item| Eqn::Calculator.calc(replace_variable item.to_s).to_i }
-						elsif type == :hash
-							args[arg_name].map! {|item| args_correct_hash item, options[:second_type] }
-						else
-							args[arg_name].map! {|item| replace_variable item.to_s }
-						end
-						
-				end
-				
-				return 0
-			end
-			
-			def args_correct_hash hash, type
-				hash.transform_keys!(&:to_sym)
-			
-				hash.keys.each do |key|
-
-					if type == :int
-						hash[key] = Eqn::Calculator.calc(replace_variable hash[key].to_s).to_i
-					elsif type == :float
-						hash[key] = Eqn::Calculator.calc(replace_variable hash[key].to_s).to_f
-					else
-						hash[key] = replace_variable hash[key].to_s
-					end
-					
-				end
-				
-				hash
-				
-			end
-			
-			def args_correct_values args
-				args_has_int :width, args
-				args_has_int :height, args
-
-				SYMBOLIZE.each do |symbol|
-					if args.key?(symbol)
-						args[symbol] = args[symbol].to_sym
-					end
-				end
-				
-				if args.key?(:position)
-
-					if ["left","center","right"].include? args[:position]
-						args[:position] = args[:position].to_sym
-					else
-						args[:position] = args[:position].to_i
-					end
-
-				end
-				
-				args
 				
 			end