petit-felix 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f7b4c8f88256743d68afb7997797a3feaa0705e90fb5c23cce6c1bee6fb7d81
-  data.tar.gz: f74620e5831b0f6c4d32e5537e14001783b2e4bc45325d27de2f3a9216325261
+  metadata.gz: b82f613c07ac215219d350be885afff66876e67b094d3358d5f2598785b370e9
+  data.tar.gz: 53dc26d5fa3834c38317f6632c16d8c99bae7ab8af77660c77fdb420be625f41
 SHA512:
-  metadata.gz: ff2c500bcdc94644659c38e36ab7fa2ee560bb06f1d619e8efdc61786a4d4167de0fb7def3eb803080ce280fd11bebe0969ef20770fa85d8ba60c314a907773f
-  data.tar.gz: e681ca163d188c1866c93337744e0a9ed3d012bd89ffc6e89d2103ad24d753a3302386307de3425198b66c2d670c4808e624cf89c229b4be7ece465eaf0c6056
+  metadata.gz: c054afc66ad63700938463e5d081deba54f3a9b064c9fdd82201d3a315b99c338cc70390873b557f780ea20e832c01f46e7d689830e9eb07d0340a64f42c2fb5
+  data.tar.gz: ef7cd3f1724ac05f70fd9d73675b72a2246bfcd2978ea0329ed4c5d73c92bda02d56a4f5dacb5bde2a3804f2001375ca752887dce029edf805521b2528201236

data/lib/felix/config.rb

@@ -9,23 +9,12 @@ module PetitFelix
 		## Prevents weird intersection conditions
 		@processed_arguments
 
-		## Default options of the application
+		# Global defaults
 		DEFAULT_OPTIONS = {
-				"columns" => 1,
-				"default_font_size" => 12,
-				"header1_size" => 32,
-				"header2_size" => 28,
-				"header3_size" => 20,
-				"header4_size" => 18,
-				"header5_size" => 16,
-				"header6_size" => 14,
-				"quote_size" => 14,
-				"margin" =>  40,
-				"font_normal" => "./assets/font/Unageo-Regular.ttf",
-				"font_italic"=> "./assets/font/Unageo-Regular-Italic.ttf",
-				"font_bold"=> "./assets/font/Unageo-ExtraBold.ttf",
-				"font_bold_italic" => "./assets/font/Unageo-ExtraBold-Italic.ttf",
-				"image_dir" => "./assets/images",
+			"image_dir" => "./assets/images",
+			"input_files" => "./md/*",
+			"output_dir" => "./output",
+			"worker" => "basic_pdf",
 		}
 
 		## Hash for custom command line argument calls
@@ -62,33 +51,78 @@ module PetitFelix
 		## then command line arguments,
 		## then finally any arguments defined in the metadata.
 
-		def load_config(args)
+		def load_config(wm, passed_args, args)
 			@processed_arguments = []
 	
 			# Felix metadata handler
 			metadata = PetitFelix::Metadata.new
 			
-			# load default options
-			options = Marshal.load(Marshal.dump(DEFAULT_OPTIONS))
+			# load global default options
+			default_options = Marshal.load(Marshal.dump(DEFAULT_OPTIONS))
 			
 			# Loads the default configuation in default.cfg
+			
+			default_config = {}
+			
 			if File.file?("./default.cfg")
 				
-				config = metadata.get_metadata(File.read("./default.cfg")[0])
-				config.keys.each do |key|
-					options[key] = config[key]
-				end
+				default_config = metadata.get_metadata(File.read("./default.cfg")[0])
 			end
 			
 			# Loads command line arguments
 			cl_args = load_cl_args(args)
 			
+			# Loads default worker options
+			worker = ""
+			worker_options = nil
+			
+			if default_options.key?("worker")
+				worker = default_options["worker"]
+			end
+			
+			if default_config.key?("worker")
+				worker = default_config["worker"]
+			end
+			
+			if cl_args.key?("worker")
+				worker = cl_args["worker"]
+			end
+			
+			if passed_args.key?("worker")
+				worker = passed_args["worker"]
+			end
+			
+			if worker != ""
+				worker_options = Marshal.load(Marshal.dump(wm.get_task_options worker))
+			end
+
+			# Now, assemble the options in order
+			# First, default options
+			options = default_options
+			
+			# Then loading default config file
+			default_config.keys.each do |key|
+				options[key] = default_config[key]
+			end
+			
+			# Then loading default worker args
+			if !worker_options.nil?
+				worker_options.keys.each do |key|
+					options[key] = worker_options[key]
+				end
+			end
+			
+			# Then loading CLI arguments
 			cl_args.keys.each do |key|
 				options[key] = cl_args[key]
 			end
+			
+			# Then loading passed arguments
+			passed_args.keys.each do |key|
+				options[key] = passed_args[key]
+			end
 
 			options
-			
 		end
 
 		# Loads command line arguments

data/lib/felix/error.rb

@@ -0,0 +1,9 @@
+module PetitFelix
+	class Error
+	
+		def print_err(error)
+			print "\n\nError: " + error + "\n"
+		end
+		
+	end
+end

data/lib/felix/generator.rb

@@ -1,4 +1,5 @@
-require "felix/task/basic_pdf_task"
+require "task/basic_pdf_task"
+require "felix/task_manager"
 
 module PetitFelix
 
@@ -6,19 +7,14 @@ module PetitFelix
 	
 		## Renders all the files in the given directory.
 		
-		def render_files(options)
-		
-			## debugging section
-			input_path = "./md/*"
-			output_path ="./output"
-			
-			if !options.key?("input_files")
-				options["input_files"] = input_path
-			end
+		def render_files(wm, options)
 			
-			options["output_dir"] = output_path
+			task = wm.get_task options["worker"]
 			
-			PetitFelix::Task::BasicPDFTask.new.render_files options
+			if !task.nil?
+				task.render_files options
+			end
+
 		end
 		
 	end

data/lib/felix/task_manager.rb

@@ -0,0 +1,74 @@
+## This class maintains all of the available tasks in the system.
+require "felix/error"
+
+module PetitFelix
+	class TaskManager
+		
+		# Gets the list of tasks loaded
+		def initialize
+			@error_printer = PetitFelix::Error.new
+			@task_list = {}
+		
+			task_list = PetitFelix::Task.constants.select {|c| PetitFelix::Task.const_get(c).is_a? Class}
+			
+			task_list.delete(:DefaultTask)
+			
+			task_list.each do |task|
+				task_instance = PetitFelix::Task.const_get(task)
+			
+				task_obj = {}
+				task_obj["id"] = task
+				task_obj["options"] = task_instance::DEFAULT_OPTIONS
+				
+				name = task_instance::NAME
+				
+				@task_list[name] = task_obj
+			end
+
+		end
+		
+		# Gets an instance of a task
+		def get_task name
+
+			if @task_list.include?(name)
+				return PetitFelix::Task.const_get(@task_list[name]["id"]).new
+			else
+				if name.nil?
+					name = "[UNDEFINED]"
+				end
+			
+				err_no_task_found name, additional_text: "Unable to find task " + name + ":\n"
+			end
+		
+			return nil
+		end
+		
+		# Gets options of a task
+		def get_task_options name
+
+			if @task_list.include?(name)
+				return @task_list[name]["options"]
+			else
+				if name.nil?
+					name = "[UNDEFINED]"
+				end
+			
+				err_no_task_found name, additional_text: "Unable to get options for Worker " + name + ":\n"
+			end
+			
+			return nil
+		end
+		
+		# No task found error
+		def err_no_task_found task, additional_text: ""
+				text = "Worker " + task.downcase + " not found. Make sure the variable \"worker\" is set correctly in your configuration settings. Available Workers: "
+				
+				@task_list.keys.each do |key|
+					text += "\n  " + key
+				end
+				
+				@error_printer.print_err text
+		end
+		
+	end
+end

data/lib/petit-felix.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 require "felix/generator"
 require "felix/config"
+require "felix/task_manager"
 
 module PetitFelix
 
@@ -10,19 +11,15 @@ module PetitFelix
 		# options - hash passed by developer containing default rendering options
 		def initialize(cl_args: [], options: {})
 	
+			# Creates a new worker manager, which has all the worker stuff
+			wm = PetitFelix::TaskManager.new
+	
 			## Loads options from default values, ./default.cfg
 			config = PetitFelix::Config.new
-			loaded_options = config.load_config cl_args
-
-			## Makes sure stuff passed by options variable overrides
-			## any previous config loading
-			options.keys.each do |option|
-				loaded_options[option] = options[option]
-			end
+			loaded_options = config.load_config wm, options, cl_args
 
 			## Starts producing stuff
-			felix_basic = PetitFelix::Generator.new
-			felix_basic.render_files loaded_options
+			PetitFelix::Generator.new.render_files wm, loaded_options
 		
 		end
 		

data/lib/task/basic_pdf_task.rb

@@ -0,0 +1,133 @@
+require "task/default_task"
+require "worker/basic_pdf_writer"
+
+module PetitFelix
+
+	module Task
+	
+		class BasicPDFTask < PetitFelix::Task::DefaultTask
+		
+			NAME = "basic_pdf"
+
+			## Default options of the application
+			DEFAULT_OPTIONS = {
+					"columns" => 1,
+					"default_font_size" => 12,
+					"header1_size" => 32,
+					"header2_size" => 28,
+					"header3_size" => 20,
+					"header4_size" => 18,
+					"header5_size" => 16,
+					"header6_size" => 14,
+					"quote_size" => 14,
+					"margin" =>  40,
+					"font_normal" => "./assets/font/Unageo-Regular.ttf",
+					"font_italic"=> "./assets/font/Unageo-Regular-Italic.ttf",
+					"font_bold"=> "./assets/font/Unageo-ExtraBold.ttf",
+					"font_bold_italic" => "./assets/font/Unageo-ExtraBold-Italic.ttf",
+					"paginator_start_count" => 1,
+					"paginator_start" => 1,
+					"paginator" => true,
+					"paginator_alternate" => false,
+					"back_text" => "",
+					"back_text_margin" => 0,
+					"back_text_size" => 14,
+					"front_title_size"=> 32,
+					"front_author_size" => 18,
+					"front_date_size" => 14,
+					"back_publisher" => "",
+					"back_publisher_size" => 14,
+					"front_publisher" => "",
+					"front_publisher_size" => 14,
+					"paginator_size" => 12,
+					"back_author" => "",
+					"back_author_size" => 16,
+			}
+
+		
+			def render_zine options
+				
+				page = File.read(options["filename"])
+				
+				# splits the page into parts for metadata and content
+				
+				# Felix metadata handler
+				metadata_helper = PetitFelix::Metadata.new
+					
+				page_data = metadata_helper.split page
+						
+				metadata = metadata_helper.get_metadata page_data[0]
+					
+				content = page_data[1]
+				
+				# stores options + metadata. metadata overrides options.
+				metaoptions = {}
+				
+				options.keys.each do |key|
+					metaoptions[key] = options[key]
+				end
+				
+				metadata.keys.each do |key|
+					metaoptions[key] = metadata[key]
+				end
+				
+				# Only continue if metadata has a title
+					
+				if metadata.key?("title")
+								
+					# Parameters
+						
+					page_layout = :portrait
+					print_scaling = :none
+					
+					if metaoptions.key?("page_layout")
+						page_layout = metaoptions["page_layout"]
+						
+						if page_layout.is_a? String
+							if page_layout.include?("portrait")
+								page_layout = :portrait
+							else 
+								if page_layout.include?("landscape")
+								page_layout = :landscape
+								end
+							end
+						end
+					end
+
+					# Generates PDF
+						
+					pdf = PetitFelix::Worker::BasicPDFWriter.new(
+						page_layout: page_layout,
+						print_scaling: print_scaling)
+
+					pdf.set_options metaoptions
+
+					# Adds extra fonts
+					
+					pdf.initialize_font
+					
+					# Title page generation
+
+					pdf.title_page
+
+					# Does the main content
+					pdf.main_block content
+					
+					# Does page numbering
+					pdf.page_numbering
+					
+					# Back page generation
+					pdf.back_page
+					
+					# Outputs to file
+					pdf.output
+					
+				end
+			end
+			
+		
+	end
+	
+end
+
+end

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module PetitFelix
     module Felix
-      VERSION = "0.1.1"
+      VERSION = "0.1.3"
     end
 end

data/lib/worker/basic_pdf_writer.rb

@@ -7,156 +7,377 @@ module PetitFelix
 	module Worker
 
 		class	BasicPDFWriter < Prawn::Document
-		
-			def page_numbering(page)
+
+			def set_options metaoptions
+				@options = metaoptions
+			end
+
+			# Initializes fonts
+			def initialize_font
+				# Fonts that must always be defined
+				fonts = [
+					"quote",
+					"header1",
+					"header2",
+					"header3",
+					"header4",
+					"header5",
+					"header6",
+					"front_default", # Default title text
+					"back_default", # Default title text
+					"paginator",
+				]
+				
+				fonts_special_default = {
+					"front_title" => "front_default",	# Title Text
+					"front_author" => "front_default",	# Author Text
+					"front_date" => "front_default", # Date Text
+					"front_publish" => "front_default", # Publication Text
+					"back_author" => "back_default", # Publication Text
+					"back_publish" => "back_default", # Publication Text
+				}
 			
-				font_size(12)
+				add_font "default"
 				
-				string = page.title + ": " ' <page>/<total>'
+				# Adds the fonts in the options
+				fonts.each do |key|
+					add_font key
+					@options[key +"_font"] = key
+				end
+				
+				# Adds special fonts with custom default fonts
+				fonts_special_default.keys.each do |key|
+					add_font key, default_font: fonts_special_default[key]
+					@options[key +"_font"] = key
+				end
 				
-			# Green page numbers 1 to 7
-			options = {
-				at: [0, 0],
-				width: bounds.width,
-				align: :right,
-				start_count_at: 1,
-				color: '000000'
-			}
-			options[:page_filter] = ->(pg) { pg > 1 }
-			
-			number_pages string, options
-		
 			end
 		
-			def back_page(pdf, metadata)
-			
-			# draw art
-			
-			box_width = 128
-			
-			pdf.font_size(24)
-			pdf.bounding_box([pdf.bounds.width * 0.5 - 64, pdf.cursor - 500], 
-			width: pdf.bounds.width - 100 - box_width,
-			height: box_width) do
-			
-				if metadata.key?("back_cover_image")
-					var = PetitFelix::Metadata.new.get_image_location(metadata["image_dir"], metadata["back_cover_image"])
+			# Adds a font to the pdf document
+			def add_font (type,
+									default_font: "default")
+
+					if @options.key?(type + "_font_normal")
 					
-					if File.file?(var)
-						pdf.image(var,
-						width: box_width,
-						height: box_width,
-						align: :center)
+						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"
+						end
+						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"
+						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],
+								:bold => font_families[default_font][:bold],
+								:bold_italic => font_families[default_font][:bold_italic]
+							})
+							
+						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
-				#transparent(0.5) { pdf.stroke_bounds }
 			end
+		
+			# Draws page numbering
 			
-			# draw name
+			def page_numbering
 			
-			pdf.font_size(20)
-			pdf.bounding_box([50, pdf.cursor - 20], 
-			width: pdf.bounds.width - 100,
-			height: 40) do
-				if metadata.key?("author_back")
-					pdf.text_box(metadata["author_back"],
-					align: :center)
+				if @options.key?("paginator")
+					if @options["paginator"]
+					
+						font "paginator"
+					
+						font_size(@options["paginator_size"].to_i)
+						
+						string = @options["title"] + ": " ' <page>'
+						
+						page_start_count = @options["paginator_start_count"].to_i
+						page_start = @options["paginator_start"].to_i
+						
+						align_odd = :left
+						align_even = :right
+						
+						if @options["front_extra_page"]
+							page_start += 1
+							align_odd = :right
+							align_even = :left
+						end
+						
+						if @options["paginator_alternate"]
+						
+							odd_options = {
+								at: [0, 0],
+								width: bounds.width,
+								align: align_odd,
+								start_count_at: page_start_count,
+							}
+							
+							odd_options[:page_filter] = ->(pg) { pg > page_start && pg % 2 == 1 }
+							
+							even_options = {
+								at: [0, bounds.left],
+								width: bounds.width,
+								align: align_even,
+								start_count_at: page_start_count + 1,
+							}
+							
+							even_options[:page_filter] = ->(pg) { pg > page_start && pg % 2 == 0 }
+							
+							number_pages string, odd_options
+							number_pages string, even_options
+							
+						else
+						
+							options = {
+								at: [0, 0],
+								width: bounds.width,
+								align: :right,
+								start_count_at: page_start_count,
+								color: '000000'
+							}
+							options[:page_filter] = ->(pg) { pg > page_start }
+							
+							number_pages string, options
+							
+						end
+						
+					end
 				end
-				#pdf.transparent(0.5) { pdf.stroke_bounds }
-			end
-			
 			end
 		
-	 	def title_page(pdf, metadata)
-			# draw title text
-			pdf.font_size(36)
-			pdf.bounding_box([25, pdf.cursor - 20], 
-			width: pdf.bounds.width - 50,
-			height: 150) do
-				pdf.text_box(metadata["title"],
-				align: :center,
-				style: :bold)
-				#pdf.transparent(0.5) { pdf.stroke_bounds }
-			end
-			
-			# draw art
-			
-			box_width = pdf.bounds.width - 100
+			# Draws back page
+			def back_page
 			
-			pdf.font_size(24)
-			pdf.bounding_box([50, pdf.cursor], 
-			width: box_width,
-			height: box_width) do
+				if @options.key?("back_cover")
+					if @options["back_cover"]
+						if @options.key?("back_extra_page") && @options["back_extra_page"]
+							start_new_page()
+						end
+					
+						start_new_page()
 			
-				if metadata.key?("front_cover_image")
-					var = PetitFelix::Metadata.new.get_image_location(metadata["image_dir"], metadata["front_cover_image"])
+						font "back_default"
+					
+						# draw end text, can be markdown
+						font_size(@options["back_text_size"].to_i)
+						
+						margin = @options["back_text_margin"].to_i
+						
+						half_margin = (margin * 0.5).floor
+						
+						bounding_box([half_margin, cursor - 20 - half_margin], 
+						width: bounds.width - margin,
+						height: 300 - margin) do
+							markdown(@options["back_text"], options: @options)
+							#transparent(0.5) { stroke_bounds }
+						end
 					
-					if File.file?(var)
-						pdf.image(var,
-						width: box_width,
-						height: box_width)
+						# draw art
+						
+						box_width = 128
+						
+						bounding_box([bounds.width * 0.5 - 64, cursor - 180], 
+						width: bounds.width - 100 - box_width,
+						height: box_width) do
+						
+							if @options.key?("back_cover_image")
+								var = PetitFelix::Metadata.new.get_image_location(@options["image_dir"], @options["back_cover_image"])
+								
+								if File.file?(var)
+									image(var,
+									width: box_width,
+									height: box_width,
+									align: :center)
+								end
+							end
+							#transparent(0.5) { stroke_bounds }
+						end
+						
+						# draw name
+						
+						font "back_author"
+						
+						font_size(@options["back_author_size"].to_i)
+						bounding_box([50, cursor - 20], 
+						width: bounds.width - 100,
+						height: 40) do
+							if @options.key?("back_author")
+								text_box(@options["back_author"],
+								align: :center)
+							end
+							#transparent(0.5) { stroke_bounds }
+						end
+						
+						font "back_publish"
+						
+						font_size(@options["back_publisher_size"].to_i)
+						bounding_box([25, cursor - 60], 
+						width: bounds.width - 50,
+						height: 32) do
+						
+							text_box(@options["back_publisher"],
+							align: :center)
+							#transparent(0.5) { stroke_bounds }
+						end
+				
 					end
 				end
-				#pdf.transparent(0.5) { pdf.stroke_bounds }
 			end
-			
-			# draw name
-			
-			pdf.font_size(24)
-			pdf.bounding_box([50, pdf.cursor - 10], 
-			width: pdf.bounds.width - 100,
-			height: 40) do
-				if metadata.key?("author")
-					pdf.text_box(metadata["author"],
-					align: :center)
+		
+		
+		# Draws title page
+	 	def title_page
+	 	
+			if @options.key?("front_cover")
+				if @options["front_cover"]
+	 	
+	 				font "front_title"
+	 	
+					# draw title text
+					font_size(@options["front_title_size"].to_i)
+					bounding_box([25, cursor ], 
+					width: bounds.width - 50,
+					height: 250) do
+						text_box(@options["title"],
+						align: :center,
+						style: :bold)
+						#transparent(0.5) { stroke_bounds }
+					end
+					
+					# draw art
+					
+					box_width = bounds.width - 150
+					
+					bounding_box([50, cursor + 10], 
+					width: box_width,
+					height: box_width) do
+					
+						if @options.key?("front_cover_image")
+							var = PetitFelix::Metadata.new.get_image_location(@options["image_dir"], @options["front_cover_image"])
+							
+							if File.file?(var)
+								image(var,
+								width: box_width,
+								height: box_width)
+							end
+						end
+						#transparent(0.5) { stroke_bounds }
+					end
+					
+					font "front_author"
+					
+					# draw author
+					
+					font_size(@options["front_author_size"].to_i)
+					bounding_box([50, cursor - 10], 
+					width: bounds.width - 100,
+					height: 30) do
+						if @options.key?("author")
+							text_box(@options["author"],
+							align: :center)
+						end
+						#transparent(0.5) { stroke_bounds }
+					end
+					
+					font "front_date"
+					
+					font_size(@options["front_date_size"].to_i)
+					bounding_box([50, cursor], 
+					width: bounds.width - 100,
+					height: 30) do
+						text_box("Original Publication: " + @options["date"],#.strftime('%e %B, %Y'),
+						align: :center)
+						#transparent(0.5) { stroke_bounds }
+					end
+					
+					font "front_publish"
+					
+					font_size(@options["front_publisher_size"].to_i)
+					bounding_box([25, cursor - 20], 
+					width: bounds.width - 50,
+					height: 32) do
+					
+						text_box(@options["front_publisher"],
+						align: :center)
+						#transparent(0.5) { stroke_bounds }
+					end
+					
+					start_new_page()
+					if @options.key?("front_extra_page") && @options["front_extra_page"]
+						start_new_page()
+					end
+					
 				end
-				#pdf.transparent(0.5) { pdf.stroke_bounds }
 			end
 			
-			pdf.font_size(16)
-			pdf.bounding_box([50, pdf.cursor], 
-			width: pdf.bounds.width - 100,
-			height: 80) do
-				pdf.text_box("Original Publication: " + metadata["date"],#.strftime('%e %B, %Y'),
-				align: :center)
-				#pdf.transparent(0.5) { pdf.stroke_bounds }
-			end
 		end
 		
-		def main_block(pdf, options, content)
+		# Draws the main block of content
+		def main_block(content)
+			font "default"
+		
 			margin = 25
 			columns = 1
 			
-			if options.key?("margin")
-				margin = options["margin"].to_i
+			if @options.key?("margin")
+				margin = @options["margin"].to_i
 			end
 			
-			if options.key?("columns")
-				columns = options["columns"].to_i
+			if @options.key?("columns")
+				columns = @options["columns"].to_i
 			end
 		
 			half_margin = (margin * 0.5).floor()
 		
 			# content generation
-			pdf.font_size(options["default_font_size"].to_i)
+			font_size(@options["default_font_size"].to_i)
 			
 			if columns == 1
-				pdf.bounding_box([half_margin, pdf.cursor - half_margin],
-					width: pdf.bounds.width-margin,
-					height: pdf.bounds.height - margin) do
+				bounding_box([half_margin, cursor - half_margin],
+					width: bounds.width-margin,
+					height: [bounds.height - 20 - margin, bounds.height - margin].min) do
 				
-					pdf.markdown(content, options: options)
+					markdown(content, options: @options)
 				end
 			else
-				pdf.column_box([half_margin, pdf.cursor - half_margin],
+				column_box([half_margin, cursor - half_margin],
 					columns: columns,
-					width: pdf.bounds.width-margin,
-					height: pdf.bounds.height - margin) do
+					width: bounds.width-margin,
+					height: [bounds.height - 20 - margin, bounds.height - margin].min) do
 				
-					pdf.markdown(content, options: options)
+					markdown(content, options: @options)
 				end
 			end
 		end
+		
+		def output
+			FileUtils.mkdir_p @options["output_dir"]
+			render_file(@options["output_dir"] + "/" + @options["title"].gsub(/[^\w\s]/, '').tr(" ", "_") + '.pdf')
+		end
 
 	end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: petit-felix
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - PunishedFelix
@@ -36,9 +36,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.10
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -46,9 +43,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.10
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.9
 description: Converts markdown files into PDF documents using options passed in a
   hash.
 email:
@@ -58,11 +52,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/felix/config.rb
+- lib/felix/error.rb
 - lib/felix/generator.rb
 - lib/felix/metadata.rb
-- lib/felix/task/basic_pdf_task.rb
-- lib/felix/task/default_task.rb
+- lib/felix/task_manager.rb
 - lib/petit-felix.rb
+- lib/task/basic_pdf_task.rb
+- lib/task/default_task.rb
 - lib/version.rb
 - lib/worker/basic_pdf_writer.rb
 homepage: https://github.com/badgernested/petitfelix

data/lib/felix/task/basic_pdf_task.rb

@@ -1,171 +0,0 @@
-require "felix/task/default_task"
-require "worker/basic_pdf_writer"
-
-module PetitFelix
-
-	module Task
-	
-		class BasicPDFTask < PetitFelix::Task::DefaultTask
-		
-			# Adds a font to the pdf document
-			def add_font pdf, metaoptions, type
-
-					if metaoptions.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"
-						
-						if metaoptions.key?(type + "_font_italic")
-							font_italic = type + "_font_italic"
-						end
-						if metaoptions.key?(type + "_font_bold")
-							font_bold = type + "_font_bold"
-						end
-						if metaoptions.key?(type + "_font_bold_italic")
-							font_bold_italic = type + "_font_bold_italic"
-						end
-					
-						pdf.font_families.update(type => {
-							:normal => metaoptions[font_normal],
-							:italic => metaoptions[font_italic],
-							:bold => metaoptions[font_bold],
-							:bold_italic => metaoptions[font_bold_italic]
-						})
-						
-					else
-					
-						pdf.font_families.update(type => {
-							:normal => metaoptions["font_normal"],
-							:italic => metaoptions["font_italic"],
-							:bold => metaoptions["font_bold"],
-							:bold_italic => metaoptions["font_bold_italic"]
-						})
-						
-					end
-			end
-		
-			def render_zine options
-				
-				# Options that are always added for this task
-				options["quote_font"] = "quote"
-				options["header1_font"] = "header1"
-				options["header2_font"] = "header2"
-				options["header3_font"] = "header3"
-				options["header4_font"] = "header4"
-				options["header5_font"] = "header5"
-				options["header6_font"] = "header6"
-				
-				dir = options["output_dir"]
-				
-				
-				page = File.read(options["filename"])
-				
-				# splits the page into parts for metadata and content
-				
-				# Felix metadata handler
-				metadata_helper = PetitFelix::Metadata.new
-					
-				page_data = metadata_helper.split page
-						
-				metadata = metadata_helper.get_metadata page_data[0]
-					
-				content = page_data[1]
-				
-				# stores options + metadata. metadata overrides options.
-				metaoptions = {}
-				
-				options.keys.each do |key|
-					metaoptions[key] = options[key]
-				end
-				
-				metadata.keys.each do |key|
-					metaoptions[key] = metadata[key]
-				end
-				
-				# Only continue if metadata has a title
-					
-				if metadata.key?("title")
-								
-					# Parameters
-						
-					page_layout = :portrait
-					print_scaling = :none
-					
-					if metaoptions.key?("page_layout")
-						page_layout = metaoptions["page_layout"]
-						
-						if page_layout.is_a? String
-							if page_layout.include?("portrait")
-								page_layout = :portrait
-							else 
-								if page_layout.include?("landscape")
-								page_layout = :landscape
-								end
-							end
-						end
-					end
-
-					# Generates PDF
-						
-					pdf = PetitFelix::Worker::BasicPDFWriter.new(
-						page_layout: page_layout,
-						print_scaling: print_scaling)
-
-					pdf.font_families.update("OpenSans" => {
-					:normal => metaoptions["font_normal"],
-					:italic => metaoptions["font_italic"],
-					:bold => metaoptions["font_bold"],
-					:bold_italic => metaoptions["font_bold_italic"]
-					})
-					
-					add_font pdf, metaoptions, "quote"
-					
-					add_font pdf, metaoptions, "header1"
-					add_font pdf, metaoptions, "header2"
-					add_font pdf, metaoptions, "header3"
-					add_font pdf, metaoptions, "header4"
-					add_font pdf, metaoptions, "header5"
-					add_font pdf, metaoptions, "header6"
-					
-					# End quote font
-					
-					pdf.font "OpenSans"
-					
-					# If the title is generated
-					if metaoptions.key?("front_cover")
-						if metaoptions["front_cover"]
-							pdf.title_page(pdf, metaoptions)
-							pdf.start_new_page()
-							if metaoptions.key?("front_extra_page") && metaoptions["front_extra_page"]
-								pdf.start_new_page()
-							end
-						end
-					end
-					
-					# Does the main content
-					pdf.main_block(pdf, metaoptions, content)
-					
-					# If the back is generated
-					if metaoptions.key?("back_cover")
-						if metaoptions["back_cover"]
-							if metaoptions.key?("back_extra_page") && metaoptions["back_extra_page"]
-								pdf.start_new_page()
-							end
-						
-							pdf.start_new_page()
-							pdf.back_page(pdf, metaoptions)
-						end
-					end
-					
-
-					FileUtils.mkdir_p dir
-					pdf.render_file(dir + "/" + metadata["title"].gsub(/[^\w\s]/, '').tr(" ", "_") + '.pdf')
-				end
-			end
-		
-	end
-	
-end
-
-end