udrs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2c17a09654a55b9b2e30ee71b9f6f5d940f32e8
+  data.tar.gz: 7ece63f00f97b75c1e955679c0f55a681a5802b3
+SHA512:
+  metadata.gz: da98fe1ffe17900362377dc6bc3baeab6807578b8746ec96f21fefde97af0f72db7a65a7354a92591879e57a1432c0e53ff89d41c0a1a210f34c9b2875dcf8c3
+  data.tar.gz: 8a944d33c23d1ce309e78c65523ba15951d25fca0fbf8c2eab62c2b5b9df8304c6e0672525c400a1e9ab1ae44b50b676b8d9913b01524a2de575cb3c09a95fcb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Michon van Dooren
+
+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.md

@@ -0,0 +1,57 @@
+# UDRS
+
+UDRS stands for the Universal Document Rendering System. This is an ambition name, and the gem does not in any way live up to the expectations that the name creates.
+
+What it does do, in short, is allow you to write a single template for a file, and then render that template to a number of formats.
+
+Currently, the following formats are supported:
+- PDF
+- ESC/P (Epson receipt printers)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'udrs'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install udrs
+
+## Usage
+
+Create a view in the normal location, with the `.udrs` extension. The use the methods provided in doc to create your document.
+
+Example template:
+
+```ruby
+    udrs_document do |doc|
+        doc.section('Hello world!')
+        doc.subsection('Introduction to the world')
+        doc.text('Lorem ipsum dolor sit amet')
+
+        doc.table([:fit, :expand, :fit]) do |table|
+            table.row(10, 'Lorem ipsum', 12.34)
+            table.row do |row|
+                row.cell(10)
+                row.cell('Lorem ipsum dolor sit amet', style: :bold)
+                row.cell(-12)
+            end
+        end
+
+        doc.footer do
+            doc.text('Copyright 1970 Anonymous', size: :small)
+        end
+    end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/lib/udrs.rb

@@ -0,0 +1,3 @@
+require 'udrs/document'
+require 'udrs/engine'
+require 'udrs/version'

data/lib/udrs/components.rb

@@ -0,0 +1,11 @@
+require 'udrs/components/code'
+require 'udrs/components/container'
+require 'udrs/components/footer'
+require 'udrs/components/header'
+require 'udrs/components/logo'
+require 'udrs/components/page_end'
+require 'udrs/components/raw'
+require 'udrs/components/spacer'
+require 'udrs/components/table'
+require 'udrs/components/text'
+require 'udrs/components/t_text'

data/lib/udrs/components/code.rb

@@ -0,0 +1,11 @@
+module UDRS
+	module Components
+		class Code
+			attr_reader :code
+
+			def initialize(code)
+				@code = code
+			end
+		end
+	end
+end

data/lib/udrs/components/container.rb

@@ -0,0 +1,11 @@
+module UDRS
+	module Components
+		class Container
+			attr_reader :items
+
+			def initialize
+				@items = []
+			end
+		end
+	end
+end

data/lib/udrs/components/footer.rb

@@ -0,0 +1,6 @@
+module UDRS
+	module Components
+		class Footer < Container
+		end
+	end
+end

data/lib/udrs/components/header.rb

@@ -0,0 +1,15 @@
+module UDRS
+	module Components
+		class Header
+			attr_reader :text, :level
+
+			LEVELS = 1..3
+
+			def initialize(text, level = 1)
+				@text = text.to_s
+				fail ArgumentError, "Invalid level: #{level}" unless LEVELS.include?(level)
+				@level = level
+			end
+		end
+	end
+end

data/lib/udrs/components/logo.rb

@@ -0,0 +1,12 @@
+module UDRS
+	module Components
+		class Logo
+			attr_reader :alignment, :valignment
+
+			def initialize(options = {})
+				@alignment = options[:alignment] || :center
+				@valignment = options[:valignment] || :top
+			end
+		end
+	end
+end

data/lib/udrs/components/page_end.rb

@@ -0,0 +1,6 @@
+module UDRS
+	module Components
+		class PageEnd
+		end
+	end
+end

data/lib/udrs/components/raw.rb

@@ -0,0 +1,11 @@
+module UDRS
+	module Components
+		class Raw
+			attr_reader :block
+
+			def initialize(&block)
+				@block = block
+			end
+		end
+	end
+end

data/lib/udrs/components/spacer.rb

@@ -0,0 +1,11 @@
+module UDRS
+	module Components
+		class Spacer
+			attr_reader :amount
+
+			def initialize(amount)
+				@amount = amount
+			end
+		end
+	end
+end

data/lib/udrs/components/t_text.rb

@@ -0,0 +1,12 @@
+module UDRS
+	module Components
+		class TText
+			attr_reader :title, :body
+
+			def initialize(title, body)
+				@title = title.to_s
+				@body = body.to_s
+			end
+		end
+	end
+end

data/lib/udrs/components/table.rb

@@ -0,0 +1,70 @@
+module UDRS
+	module Components
+		class Table
+			attr_reader :columns, :rows
+
+			COLUMN_SIZES = %i(fit expand hide)
+
+			def initialize(*columns, &block)
+				@columns = columns
+				invalid = (columns.reject { |c| c.is_a?(Fixnum) } - COLUMN_SIZES).uniq
+				fail ArgumentError, "Invalid column size(s): #{invalid.join(', ')}" unless invalid.empty?
+
+				@rows = []
+				block.call(self)
+			end
+
+			def row(*args, &block)
+				@rows << Row.new(self, *args, &block)
+			end
+
+			def get_column_widths
+				return columns.each_with_index.map do |column, i|
+					case column
+						# Fixed width
+						when Fixnum
+							next [column, column, column]
+
+						# Fit
+						when :fit
+							size = rows.map { |r| r.cells[i] }.map(&:text).map(&:size).max
+							next [size, size, size]
+
+						# Expand
+						when :expand
+							size = rows.map { |r| r.cells[i] }.map(&:text).map(&:size).max
+							next [0, size, 9999]
+
+						# Hide
+						when :hide
+							next [0, 0, 0]
+
+						else
+							fail ArgumentError, "Cannot calculate column width for #{column}"
+					end
+				end
+			end
+		end
+
+		class Row
+			attr_reader :cells
+
+			def initialize(table, *args, &block)
+				options = {}
+				options = args.pop if args.last.is_a?(Hash)
+
+				@cells = []
+				args.each { |c| cell(c, options) }
+				block.call(self) if block
+
+				if @cells.size != table.columns.size
+					fail ArgumentError, "Row contains #{cells.size} cells, but #{table.columns.size} are required"
+				end
+			end
+
+			def cell(text, options = {})
+				@cells << Text.new(text, options)
+			end
+		end
+	end
+end

data/lib/udrs/components/text.rb

@@ -0,0 +1,33 @@
+require 'attribute_predicates'
+
+module UDRS
+	module Components
+		class Text
+			attr_reader :text, :is_bold, :is_italic, :is_underline, :size, :alignment
+
+			SIZES = %i(tiny small normal medium large huge)
+			ALIGNENTS = %i(left center right)
+
+			def initialize(text, options = {})
+				@text = text.to_s
+
+				# Text size
+				@size = :normal
+				@size = options[:size] if options[:size].present?
+				fail ArgumentError, "Invalid size: #{@size}" unless SIZES.include?(@size)
+
+				# Style(s)
+				style = [*options[:style]]
+				@is_bold = style.delete(:bold)
+				@is_italic = style.delete(:italic)
+				@is_underline = style.delete(:underline)
+				fail ArgumentError, "Invalid style(s): #{style.join(', ')}" unless style.empty?
+
+				# Alignment
+				@alignment = :left
+				@alignment = options[:align] if options[:align].present?
+				fail ArgumentError, "Invalid alignment: #{@alignment}" unless ALIGNENTS.include?(@alignment)
+			end
+		end
+	end
+end

data/lib/udrs/document.rb

@@ -0,0 +1,109 @@
+require 'udrs/components'
+require 'udrs/renderers'
+
+require 'attribute_predicates'
+
+module UDRS
+	class Document
+		attr_reader :is_rendering
+
+		TYPES = %i(pdf escp)
+
+		def initialize(type)
+			fail ArgumentError, "Unknown udrs type #{type}" unless TYPES.include?(type)
+			@type = type
+			case type
+				when :pdf
+					@renderer = Renderers::PDFRenderer.new
+				when :escp
+					@renderer = Renderers::ESCPRenderer.new
+			end
+
+			@container = Components::Container.new
+			@rendering = false
+		end
+
+		# Check the document type
+		def pdf?
+			return @type == :pdf
+		end
+		def escp?
+			return @type == :escp
+		end
+
+		# Add components
+		def end_page(*args)
+			add_component(Components::PageEnd.new(*args))
+		end
+		def spacer(*args)
+			add_component(Components::Spacer.new(*args))
+		end
+		def section(txt)
+			add_component(Components::Header.new(txt, 1))
+		end
+		def subsection(txt)
+			add_component(Components::Header.new(txt, 2))
+		end
+		def subsubsection(txt)
+			add_component(Components::Header.new(txt, 3))
+		end
+		def text(*args)
+			add_component(Components::Text.new(*args))
+		end
+		def ttext(*args)
+			add_component(Components::TText.new(*args))
+		end
+		def logo(*args)
+			add_component(Components::Logo.new(*args))
+		end
+		def code(*args)
+			add_component(Components::Code.new(*args))
+		end
+		def table(*args, &block)
+			add_component(Components::Table.new(*args, &block))
+		end
+		def raw(*args, &block)
+			add_component(Components::Raw.new(*args, &block))
+		end
+		def footer(*args, &block)
+			footer = Components::Footer.new(*args)
+			using_container(footer, &block)
+			add_component(footer)
+		end
+
+		# Render the components using the renderer
+		def render
+			unless @rendered
+				@is_rendering = true
+				@rendered = @renderer.render(@container)
+				@is_rendering = false
+			end
+			return @rendered
+		end
+		def render!
+			@rendered = nil
+			return render
+		end
+
+		private
+
+		# If the rendering has already started, immediately render instead of caching
+		#
+		# This _should_ only happen in blocks passed to raw
+		def add_component(component)
+			if is_rendering?
+				@renderer.render_item(component)
+			else
+				@container.items << component
+			end
+		end
+
+		# Perform a block with the current container set to something else
+		def using_container(container, &block)
+			old_container = @container
+			@container = container
+			block.call
+			@container = old_container
+		end
+	end
+end

data/lib/udrs/engine.rb

@@ -0,0 +1,14 @@
+require 'udrs/engine/rails_helper'
+require 'udrs/engine/template_renderer'
+
+module UDRS
+	module Engine
+		class RailsEngine < Rails::Engine
+			ActionView::Base.send(:include, UDRS::Engine::RailsHelper)
+			ActionView::Template.register_template_handler(:udrs, UDRS::Engine::TemplateRenderer)
+
+			Mime::Type.register_alias('application/pdf', :pdf) if !Mime::Type.lookup_by_extension(:pdf)
+			Mime::Type.register_alias('application/octet-stream', :escp) if !Mime::Type.lookup_by_extension(:escp)
+		end
+	end
+end

data/lib/udrs/engine/rails_helper.rb

@@ -0,0 +1,11 @@
+module UDRS
+	module Engine
+		module RailsHelper
+			def udrs_document(&block)
+				doc = UDRS::Document.new(params[:format].to_sym)
+				block.call(doc)
+				return doc.render
+			end
+		end
+	end
+end

data/lib/udrs/engine/template_renderer.rb

@@ -0,0 +1,14 @@
+module UDRS
+	module Engine
+		class TemplateRenderer
+			def self.call(template)
+				return <<-END
+					output = #{template.source.strip}
+					@filename = "\#{controller.action_name}.\#{params[:format]}"
+					controller.response.headers['Content-Disposition'] = 'inline; filename="\#{@filename}"'
+					return output
+				END
+			end
+		end
+	end
+end

data/lib/udrs/renderers.rb

@@ -0,0 +1,2 @@
+require 'udrs/renderers/escp_renderer'
+require 'udrs/renderers/pdf_renderer'

data/lib/udrs/renderers/base.rb

@@ -0,0 +1,17 @@
+module UDRS
+	module Renderers
+		class Base
+			def render_item(item)
+				method_name = "render_#{item.class.name.demodulize.underscore}"
+				fail NotImplementedError, "Cannot render #{item.class.name}" unless respond_to?(method_name, true)
+				method(method_name).call(item)
+			end
+
+			protected
+
+			def render_items(items)
+				items.each(&method(:render_item))
+			end
+		end
+	end
+end

data/lib/udrs/renderers/escp_renderer.rb

@@ -0,0 +1,156 @@
+require 'udrs/renderers/base'
+require 'udrs/renderers/escp_renderer/font.rb'
+require 'udrs/renderers/escp_renderer/line.rb'
+require 'udrs/renderers/escp_renderer/table.rb'
+
+module UDRS
+	module Renderers
+		# The renderer for ESC/P, short for Epson Standard Code for Printers
+		class ESCPRenderer < Base
+			NUL = 0.chr
+			EOT = 4.chr
+			ENQ = 5.chr
+			HT = 9.chr
+			LF = 10.chr
+			FF = 12.chr
+			CR = 13.chr
+			DLE = 16.chr
+			DC4 = 20.chr
+			CAN = 24.chr
+			ESC = 27.chr
+			FS = 28.chr
+			GS = 29.chr
+
+			CHARACTER_MAP = {
+				'€' => "\xD5",
+				'£' => "\x9C",
+				'¢' => "\xBD",
+				'«' => "\xAE",
+				'»' => "\xAF",
+				'→' => "\xAF",
+				'©' => "\xB8",
+				'®' => "\xA9",
+			}
+
+			CODE_NUM = 48 # The code num for PDF417
+			CODE_SIZE = 3
+
+			def render(container)
+				@buffer = ''
+				@buffer << "#{ESC}@" # Re-init printer
+				@buffer << "#{ESC}t#{19.chr}" # Reset character code table to PC858: Euro
+				@buffer << "#{ESC}M#{1.chr}" # Set the font
+				@buffer << "#{ESC}G#{0.chr}" # Set double-strike to off
+				apply_font_size(:normal)
+				apply_bold(false)
+				apply_underline(:off)
+
+				# Render the items
+				render_item(container)
+				render_page_end(nil)
+
+				# Open the cash drawer
+				@buffer << "#{ESC}p#{0.chr}#{100.chr}#{100.chr}"
+
+				# Replace special characters
+				buffer = @buffer.dup
+				CHARACTER_MAP.each do |char_orig, char_new|
+					buffer.gsub!(char_orig, char_new)
+				end
+
+				return buffer
+			end
+
+			private
+
+			##############################
+			# Render methods
+			##############################
+
+			def render_page_end(page_end)
+				# Cut the paper at page end
+				@buffer << "\n\n\n\n\n\x1DV1\n"
+			end
+
+			def render_spacer(spacer)
+				add_spacer
+			end
+
+			def render_header(header)
+				case header.level
+					when 1
+						add_spacer
+						add_line(header.text, size: :huge, bold: true, align: :center)
+						add_spacer
+
+					when 2
+						add_spacer
+						add_line(header.text, size: :large, bold: true)
+
+					when 3
+						add_line(header.text, size: :medium, bold: true)
+
+					else
+						fail ArgumentError, "Invalid header level: #{header.level}"
+				end
+			end
+
+			def render_text(item)
+				add_line(item.text, text_to_options(item).merge(reflow: true))
+			end
+
+			def render_t_text(item)
+				add_line("#{item.title}: #{item.body}", size: :normal, bold: false, underline: false, reflow: true)
+			end
+
+			def render_logo(logo)
+				@buffer << "#{GS}(L#{6.chr}#{0.chr}#{48.chr}#{69.chr}#{32.chr}#{32.chr}#{1.chr}#{1.chr}"
+				@last_added = :logo
+				add_spacer
+			end
+
+			def render_code(code)
+				get_pl_ph = proc do |*params|
+					# From the docs:
+					# pL, pH specify the number of parameters after pH as (pL + pH*256)
+					return [params.size % 256, params.size / 256]
+				end
+
+				# The way to build a single line/setting of the code
+				part = proc do |function, *params| 
+					fail ArgumentError unless params.all? { |p| p.is_a?(String) && p.length == 1 }
+					pl, ph = get_pl_ph.call(CODE_NUM, function, *params)
+					next "#{GS}(k#{pl.chr}#{ph.chr}#{CODE_NUM.chr}#{function.chr}#{params.join}"
+				end
+
+				@buffer << "\n"
+				@buffer << "#{ESC}a#{1.chr}" # Center
+				@buffer << part.call(67, CODE_SIZE.chr) # Set size
+				@buffer << part.call(69, 51.chr) # Set error correction
+				@buffer << part.call(80, 48.chr, *code.code.chars) # Set the code data
+				@buffer << part.call(81, 48.chr) # Start the print
+				@buffer << "#{ESC}a#{0.chr}" # End centering
+
+				@last_added = :code
+			end
+
+			def render_container(container)
+				render_items(container.items)
+			end
+
+			def render_footer(footer)
+				add_spacer
+				render_items(footer.items)
+			end
+
+			def render_raw(raw)
+				raw.block.call(@buffer)
+			end
+
+			def add_spacer
+				@buffer << ' ' * @line_width unless @last_added == :spacer
+				@last_added = :spacer
+			end
+		end
+	end
+end

data/lib/udrs/renderers/escp_renderer/font.rb

@@ -0,0 +1,84 @@
+module UDRS
+	module Renderers
+		# Font styling
+		class ESCPRenderer < Base
+			private 
+
+			FONT_SIZE = {
+				tiny: [0b0100_0001, 56],
+				small: [0b0100_0001, 56],
+				normal: [0b0100_0001, 56],
+				medium: [0b0100_0000, 42],
+				large:  [0b0111_0111, 28],
+				huge:   [0b0111_0110, 21],
+			}
+
+			UNDERLINE = {
+				off: 0,
+				light: 1,
+				medium: 2,
+			}
+
+			def text_to_options(item)
+				return {
+					size: item.size,
+					bold: item.is_bold?,
+					underline: item.is_underline?,
+					align: item.alignment,
+				}
+			end
+
+			def font(options = {}, &block)
+				font_size(options[:size] || @font_size) do
+					bold(options[:bold] || @font_bold) do
+						underline(options[:underline] || @font_underline) do
+							block.call
+						end
+					end
+				end
+			end
+
+			def font_size(size, &block)
+				old_size = @font_size
+				apply_font_size(size)
+				block.call
+				apply_font_size(old_size)
+			end
+
+			def apply_font_size(size)
+				fail ArgumentError, "Invalid font size: #{size}" unless FONT_SIZE.key?(size)
+				@font_size = size
+				size = FONT_SIZE[size]
+				@buffer << "#{ESC}!#{size[0].chr}"
+				@line_width = size[1]
+			end
+
+			def bold(bold, &block)
+				old_bold = @font_bold
+				apply_bold(bold)
+				block.call
+				apply_bold(old_bold)
+			end
+
+			def apply_bold(status)
+				fail ArgumentError, 'Status must be a boolean' unless status == !!status
+				@font_bold = status
+				@buffer << "#{ESC}E#{status ? 1.chr : 0.chr}"
+			end
+
+			def underline(underline, &block)
+				old_underline = @font_underline
+				apply_underline(underline)
+				block.call
+				apply_underline(old_underline)
+			end
+
+			def apply_underline(underline)
+				underline = :medium if underline == !!underline
+				fail ArgumentError, 'Invalid underline value' unless UNDERLINE.key?(underline)
+				@font_underline = underline
+				@buffer << "#{ESC}_#{UNDERLINE[underline].chr}"
+			end
+		end
+	end
+end

data/lib/udrs/renderers/escp_renderer/line.rb

@@ -0,0 +1,77 @@
+require 'facets/string/word_wrap'
+
+module UDRS
+	module Renderers
+		# Line methods
+		class ESCPRenderer < Base
+			private
+
+			def add_lines(lines, options = {})
+				lines.each { |l| add_line(l, options) }
+			end
+
+			def add_line(line, options = {})
+				# Reflow if needed
+				line = line.gsub(/\s+/, ' ') if options[:reflow]
+
+				# If multiple lines, process each separately
+				if line.include?("\n")
+					line.split("\n").each { |line| add_line(line, options) }
+					return 
+				end
+
+				# Apply the font
+				font(options) do
+					# Get width from options
+					width = options[:width] || @line_width
+					width = (width * @line_width).ceil if width.is_a?(Float)
+					fail ArgumentError, "Width cannot exceed max line width" if width > @line_width
+
+					# Get indent from options
+					indent = options[:indent] || 0
+					fail ArgumentError, "Indent cannot be larger than width" if indent >= width
+					width -= indent
+
+					# Process the line into lines
+					lines = line_to_block(line, width, options)
+
+					# Apply indent
+					lines.map! { |line| (' ' * indent) + line }
+
+					# Store lines
+					@buffer << lines.join
+					@last_added = :line
+				end
+			end
+
+			def line_to_block(line, width, options = {})
+				line = line.to_s
+				if line.include?("\n")
+					lines = line.split("\n")
+					return lines.map { |line| line_to_block(line) }.flatten
+				end
+
+				# Wrap lines
+				lines = line.word_wrap(width).split("\n")
+
+				# Pad all lines
+				lines.map! do |line|
+					diff = width - line.size
+					case options[:align] || :left
+						when :left
+							next line + (' ' * diff)
+						when :right
+							next (' ' * diff) + line
+						when :center
+							half = diff / 2.0
+							next (' ' * half.ceil) + line + (' ' * half.floor)
+						else
+							fail ArgumentError, "Invalid alignment #{options[:align]}"
+					end
+				end
+
+				return lines
+			end
+		end
+	end
+end

data/lib/udrs/renderers/escp_renderer/table.rb

@@ -0,0 +1,70 @@
+module UDRS
+	module Renderers
+		# Tables
+		class ESCPRenderer < Base
+			private
+
+			def render_table(table)
+				add_spacer
+
+				# Get the column widths
+				column_widths = _calculate_table_column_widths(table)
+
+				# For each of the rows, render each cell according to the column with + cell properties
+				table.rows.each do |row|
+					# Get the non-hidden cells + their blocks
+					cells = []
+					parts = []
+					column_widths.zip(row.cells).each do |width, cell|
+						next if width == 0
+						cells << cell
+						parts << line_to_block(cell.text, width, text_to_options(cell))
+					end
+
+					# Make all the blocks have the same amount of lines
+					max_length = parts.map(&:size).max
+					column_widths.zip(parts).each do |width, lines|
+						lines << (' ' * width) while lines.size < max_length
+					end
+
+					# Add lines
+					parts.transpose.each do |line_parts|
+						cells.zip(line_parts).each_with_index do |(cell, part), i|
+							@buffer << ' ' if i > 0
+							font(text_to_options(cell)) do
+								@buffer << part
+							end
+						end
+					end
+				end
+
+				@last_added = :table
+				add_spacer
+			end
+
+			def _calculate_table_column_widths(table)
+				# Calculate the column widths
+				widths = table.get_column_widths
+				totals = [widths.map(&:first).sum, widths.map(&:second).sum, widths.map(&:third).sum]
+				columns = (table.columns - [:hide]).size
+				spacers = columns - 1
+
+				# Calculate the flex space
+				flex = @line_width - totals[0] - spacers
+				flex_columns = table.columns.count(:expand)
+				flex_indexes = table.columns.each_with_index.select { |c, i| c == :expand }.map(&:second)
+				flex_total_weight = widths.values_at(*flex_indexes).map(&:second).sum
+				fail ArgumentError, 'Table cannot fit' if flex < flex_columns
+
+				# Determine the final column width
+				final_widths = widths.map do |min, desired, max|
+					next min if min == max
+					next (flex * (desired / flex_total_weight - 0.001)).round
+				end
+				fail ArgumentError, 'Unable to calculate column widths' if final_widths.sum + spacers > @line_width
+
+				return final_widths
+			end
+		end
+	end
+end

data/lib/udrs/renderers/pdf_renderer.rb

@@ -0,0 +1,180 @@
+require 'udrs/renderers/base'
+
+require 'prawn'
+require 'prawn/table'
+require 'barby/barcode/qr_code'
+require 'barby/outputter/prawn_outputter'
+
+module UDRS
+	module Renderers
+		class PDFRenderer < Base
+			FORMAT_TIME = '%A %-d %B %Y %H:%M (%P)'
+
+			def render(container)
+				# Create the pdf
+				@pdf = Prawn::Document.new
+
+				# Allow bold fonts
+				@pdf.font_families.update(
+					'DejaVuSans' => {
+						normal: 'app/assets/DejaVuSans.ttf',
+						bold: 'app/assets/DejaVuSans-Bold.ttf',
+					},
+				)
+				@pdf.font('DejaVuSans', size: @pdf.font_size)
+
+				# Render the items
+				render_item(container)
+
+				# Render the pdf
+				return @pdf.render
+			end
+
+			private
+
+			SIZE_MAP = {
+				tiny: 9,
+				small: 11,
+				normal: 12,
+				medium: 14,
+				large: 16,
+				huge: 18,
+			}
+
+			def render_page_end(page_end)
+				@pdf.start_new_page
+			end
+
+			def render_spacer(spacer)
+				if spacer.amount > 0
+					@pdf.move_down(spacer.amount)
+				else
+					@pdf.move_up(-1 * spacer.amount)
+				end
+			end
+
+			def render_header(header)
+				case header.level
+					when 1
+						@pdf.move_down(15)
+						@pdf.font(@pdf.font.name, size: SIZE_MAP[:huge], style: :bold) do
+							@pdf.text(header.text)
+						end
+
+					when 2
+						@pdf.move_down(10)
+						@pdf.font(@pdf.font.name, size: SIZE_MAP[:large], style: :bold) do
+							@pdf.text(header.text)
+						end
+
+					when 3
+						@pdf.move_down(5)
+						@pdf.font(@pdf.font.name, size: SIZE_MAP[:medium], style: :bold) do
+							@pdf.text(header.text)
+						end
+
+					else
+						fail ArgumentError, "Invalid header level: #{header.level}"
+				end
+			end
+
+			def render_text(item)
+				@pdf.font('DejaVuSans', style: _text_to_style(item), size: SIZE_MAP[item.size]) do
+					@pdf.text(item.text, align: item.alignment)
+				end
+			end
+
+			def render_t_text(item)
+				c = @pdf.cursor
+				title_width = @pdf.bounds.width / 4
+				@pdf.bounding_box([0, c], width: @pdf.bounds.width) do
+					title_box = @pdf.bounding_box([0, 0], width: title_width) do
+						@pdf.font('DejaVuSans', style: :bold) do
+							@pdf.text(item.title)
+						end
+					end
+					content_box = @pdf.bounding_box(
+						[title_width, title_box.height],
+						width: @pdf.bounds.width - title_width,
+					) do
+						@pdf.text(item.body)
+					end
+					@pdf.move_cursor_to([title_box.bottom, content_box.bottom].max)
+				end
+			end
+
+			def render_logo(logo)
+				@pdf.image('app/assets/images/logo.png', position: logo.alignment, vposition: logo.valignment)
+			end
+
+			def render_code(code)
+				qrcode = Barby::QrCode.new(code.code)
+				outputter = Barby::PrawnOutputter.new(qrcode)
+				dim = 4
+				@pdf.move_down(outputter.full_height * dim)
+				outputter.annotate_pdf(@pdf, xdim: dim)
+				@pdf.move_up(outputter.full_height)
+			end
+
+			def render_table(table)
+				table_data = table.rows.map { |r| r.cells.map(&:text) }
+				@pdf.table(table_data) do |tbl|
+					# Lines between all cells
+					tbl.cells.borders = %i(bottom right)
+					tbl.rows(-1).borders = %i(right)
+					tbl.columns(-1).borders = %i(bottom)
+					tbl.rows(-1).columns(-1).borders = []
+
+					# Column sizes
+					table.columns.each_with_index do |width, ci|
+						next if width == :expand # Default, so do nothing
+
+						# For fit, calculate the needed width
+						if width == :fit
+							widths = table.rows.map do |row|
+								cell = row.cells[ci]
+								next @pdf.width_of(cell.text, style: _text_to_style(cell), size: SIZE_MAP[cell.size])
+							end
+							width = widths.max
+						end
+
+						pdf_cell = tbl.column(ci).first
+						pdf_cell.width = width + pdf_cell.padding_left + pdf_cell.padding_right
+					end
+
+					# Cell styles
+					table.rows.each_with_index do |row, ri|
+						row.cells.each_with_index do |cell, ci|
+							pdf_cell = tbl.rows(ri).columns(ci)
+							pdf_cell.align = cell.alignment
+							pdf_cell.font_style = _text_to_style(cell)
+							pdf_cell.font_size = SIZE_MAP[cell.size]
+						end
+					end
+				end
+			end
+
+			def render_container(container)
+				render_items(container.items)
+			end
+
+			def render_footer(footer)
+				@pdf.bounding_box([0, 35], width: @pdf.bounds.width, height: 35) do
+					render_items(footer.items)
+				end
+			end
+
+			def render_raw(raw)
+				raw.block.call(@pdf)
+			end
+
+			def _text_to_style(text)
+				style = :normal
+				style = :bold if text.is_bold?
+				# style = :italic if text.is_italic?
+				# style = :underline if text.is_underline?
+				return style
+			end
+		end
+	end
+end

data/lib/udrs/version.rb

@@ -0,0 +1,3 @@
+module Udrs
+	VERSION = "0.1.0"
+end

data/udrs.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'udrs/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'udrs'
+  spec.version       = Udrs::VERSION
+  spec.authors       = ['Michon van Dooren']
+  spec.email         = ['michon1992@gmail.com']
+
+  spec.summary       = %q{Simple templates to generate documents in various formats.}
+  spec.homepage      = 'https://github.com/MaienM/UDRS'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir.glob('lib/**/**/*') + %w(udrs.gemspec LICENSE.txt README.md)
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'attribute_predicates', '~> 0.2'
+  spec.add_dependency 'barby', '~> 0.6'
+  spec.add_dependency 'facets', '~> 3'
+  spec.add_dependency 'prawn', '~> 2'
+  spec.add_dependency 'prawn-table', '~> 0.2'
+  spec.add_dependency 'rqrcode', '~> 0.9'
+  spec.add_runtime_dependency 'rails', '~> 4'
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: udrs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michon van Dooren
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: attribute_predicates
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: barby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: facets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: prawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: prawn-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rqrcode
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- michon1992@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/udrs.rb
+- lib/udrs/components.rb
+- lib/udrs/components/code.rb
+- lib/udrs/components/container.rb
+- lib/udrs/components/footer.rb
+- lib/udrs/components/header.rb
+- lib/udrs/components/logo.rb
+- lib/udrs/components/page_end.rb
+- lib/udrs/components/raw.rb
+- lib/udrs/components/spacer.rb
+- lib/udrs/components/t_text.rb
+- lib/udrs/components/table.rb
+- lib/udrs/components/text.rb
+- lib/udrs/document.rb
+- lib/udrs/engine.rb
+- lib/udrs/engine/rails_helper.rb
+- lib/udrs/engine/template_renderer.rb
+- lib/udrs/renderers.rb
+- lib/udrs/renderers/base.rb
+- lib/udrs/renderers/escp_renderer.rb
+- lib/udrs/renderers/escp_renderer/font.rb
+- lib/udrs/renderers/escp_renderer/line.rb
+- lib/udrs/renderers/escp_renderer/table.rb
+- lib/udrs/renderers/pdf_renderer.rb
+- lib/udrs/version.rb
+- udrs.gemspec
+homepage: https://github.com/MaienM/UDRS
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Simple templates to generate documents in various formats.
+test_files: []
+has_rdoc: