pdf_tempura 0.0.2

data/lib/pdf_tempura/document/page.rb

@@ -0,0 +1,33 @@
+module PdfTempura
+  class Document::Page
+    include Document::Validation
+    include Document::DefaultCommands
+
+    def initialize(page_number, options = {})
+      @number = page_number
+      @fields = []
+      @options = options
+
+      validate!
+    end
+
+    attr_reader :number
+
+    validates :number, type: Numeric
+
+    def ==(other)
+      self.number == other.number
+    end
+
+    def data
+      @data ||= {}
+    end
+
+    def data=(data)
+      @data = data.extend(Extensions::Hash::StringifyKeys).stringify_keys!
+    end
+
+  end
+end
+
+require_relative "default_commands"

data/lib/pdf_tempura/document/table.rb

@@ -0,0 +1,95 @@
+module PdfTempura
+  class Document::Table < Document::Field::Base
+
+    attr_accessor :columns,:name,:row_height,:padding,:cell_padding,:row_count
+
+    validates :row_height, type: Numeric
+    validates :row_count, type: Numeric
+    validates :padding, type: Array, inner_type: Numeric, count: 4
+    validates :cell_padding, type: Numeric
+
+    def initialize(name,coordinates,options = {},&block)
+      super name, coordinates, [0,0], options
+
+      @columns = []
+
+      instance_eval(&block) if block_given?
+    end
+
+    def width
+      table_width + padding_width
+    end
+
+    def height
+      @height ||= row_height * row_count
+    end
+
+    def row_height
+      @row_height ||= height.to_f / row_count.to_f
+    end
+
+    def text_column(name, width, options = {})
+      columns << Document::Table::TextColumn.new(name, width, row_height, @options.merge(options))
+    end
+
+    def checkbox_column(name, width, options = {})
+      columns << Document::Table::CheckboxColumn.new(name, width, row_height, @options.merge(options))
+    end
+
+    def boxed_character_column(name, options = {}, &block)
+      columns << Document::Table::BoxedCharacterColumn.new(name, row_height, @options.merge(options), &block)
+    end
+
+    def space(width)
+      columns << Document::Table::Spacer.new(width, row_height)
+    end
+
+    def fields_for(values, &block)
+      values.inject(self.y) do |y, value_hash|
+        generate_columns(y, value_hash, &block)
+        y - row_height
+      end
+    end
+
+    private
+
+    def generate_columns(y, values)
+      columns.inject(self.x) do |x, column|
+        yield column.field_at([x,y]), values[column.name] if column.generates_field?
+        x + column.width + cell_padding
+      end
+    end
+
+    def table_width
+      columns.map(&:width).inject(0, :+)
+    end
+
+    def padding_width
+      (columns.any?) ? cell_padding * (columns.count - 1) : 0
+    end
+
+    def validate_height
+      unless row_count && (@row_height || @height)
+        raise ArgumentError.new("You must pass number_of_rows and either height or row_height")
+      end
+    end
+
+    def load_options(options)
+      @height = options["height"]
+      @row_height = options["row_height"]
+      @row_count = options["number_of_rows"]
+      @padding = options["padding"] || [0,0,0,0]
+      @cell_padding = options["cell_padding"] || 0
+      @options = options
+
+      validate_height
+    end
+
+  end
+end
+
+require_relative 'table/column'
+require_relative 'table/text_column'
+require_relative 'table/checkbox_column'
+require_relative 'table/spacer'
+require_relative 'table/boxed_character_column'

data/lib/pdf_tempura/document/table/boxed_character_column.rb

@@ -0,0 +1,20 @@
+module PdfTempura
+  class Document::Table::BoxedCharacterColumn < Document::Table::Column
+
+    def initialize(name, height, options = {}, &block)
+      @name = name
+      @height = height
+      @options = options
+      @block = block if block_given?
+    end
+
+    def width
+      field_at([0,0]).width
+    end
+
+    def field_at(coordinates)
+      PdfTempura::Document::BoxedCharacters.new(@name, coordinates, @height, @options, &@block)
+    end
+
+  end
+end

data/lib/pdf_tempura/document/table/checkbox_column.rb

@@ -0,0 +1,9 @@
+module PdfTempura
+  class Document::Table::CheckboxColumn < Document::Table::Column
+
+    def field_at(coordinates)
+      Document::CheckboxField.new(name, coordinates, [width,height], options)
+    end
+
+  end
+end

data/lib/pdf_tempura/document/table/column.rb

@@ -0,0 +1,18 @@
+module PdfTempura
+  class Document::Table::Column
+
+    attr_reader :name, :width, :options, :height
+
+    def initialize(name, width, height, options = {})
+      @name = name
+      @width = width
+      @height = height
+      @options = options
+    end
+
+    def generates_field?
+      true
+    end
+
+  end
+end

data/lib/pdf_tempura/document/table/spacer.rb

@@ -0,0 +1,13 @@
+module PdfTempura
+  class Document::Table::Spacer < Document::Table::Column
+
+    def initialize(width, height)
+      super nil, width, height
+    end
+
+    def generates_field?
+      false
+    end
+
+  end
+end

data/lib/pdf_tempura/document/table/text_column.rb

@@ -0,0 +1,9 @@
+module PdfTempura
+  class Document::Table::TextColumn < Document::Table::Column
+
+    def field_at(coordinates)
+      PdfTempura::Document::TextField.new(name, coordinates, [width, height], options)
+    end
+
+  end
+end

data/lib/pdf_tempura/document/text_field.rb

@@ -0,0 +1,18 @@
+require_relative 'character_field'
+
+module PdfTempura
+  class Document::TextField < Document::CharacterField
+
+    private
+
+    def load_options(options)
+      super
+
+      @alignment = (options["alignment"] || "left").to_s
+      @multi_line = options["multi_line"] || false
+      @valign = options["valign"] || "center"
+      @leading = options["leading"] || 0
+    end
+
+  end
+end

data/lib/pdf_tempura/document/validation.rb

@@ -0,0 +1,79 @@
+module PdfTempura
+  module Document::Validation
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def validations
+        @validations ||= (superclass.respond_to?(:validations) ? superclass.validations.dup : {})
+      end
+
+      private
+
+      def validates(name, validation_options)
+        if self.instance_methods.include?(name)
+          validations[name] = validation_options
+        else
+          raise NoMethodError, "Can't validate undefined method '#{name}'."
+        end
+      end
+
+    end
+
+    private
+
+    def validate!
+      self.class.validations.each do |method, validation_options|
+        validation_options.each do |validation_type, values|
+          find_validator(validation_type).new.validate(self, method, values)
+        end
+      end
+    end
+
+    def find_validator(validation_type)
+      validator_name = validation_type.to_s.split("_").push("validator").map(&:capitalize).join
+      Document::Validation.const_get(validator_name)
+    end
+
+    class RequiredValidator
+      def validate(object, method, not_used)
+        raise ArgumentError, "#{method.capitalize} is required." unless object.send(method)
+      end
+    end
+
+    class BooleanValidator
+      def validate(object, method, not_used)
+        raise ArgumentError, "#{method.capitalize} must be of type boolean." unless object.send(method).is_a?(TrueClass) || object.send(method).is_a?(FalseClass)
+      end
+    end
+
+    class InclusionValidator
+      def validate(object, method, values)
+        raise ArgumentError, "#{method.capitalize} must be one of the following values: #{values.join(", ")}." unless values.include?(object.send(method))
+      end
+    end
+
+    class TypeValidator
+      def validate(object, method, type)
+        raise ArgumentError, "#{method.capitalize} must be of type #{type.inspect}." unless object.send(method).is_a?(type)
+      end
+    end
+
+    class InnerTypeValidator
+      def validate(object, method, type)
+        raise ArgumentError, "#{method.capitalize} must contain only #{type.inspect} values." unless object.send(method).all?{ |inner| inner.is_a?(type) }
+      end
+    end
+
+    class CountValidator
+      def validate(object, method, count)
+        count_objects = object.send(method)
+        raise ArgumentError, "#{method.capitalize} must contain #{count} values." unless count_objects.respond_to?(:count) && count_objects.count == count
+      end
+    end
+
+  end
+end

data/lib/pdf_tempura/extensions/hash/stringify_keys.rb

@@ -0,0 +1,35 @@
+module PdfTempura
+  module Extensions
+    module Hash
+      module StringifyKeys
+
+        def stringify_keys
+          dup.extend(StringifyKeys).stringify_keys!
+        end
+
+        def stringify_keys!
+          keys.each do |k|
+            stringify_keys_recursively!(self[k])
+            self[k.to_s] = self.delete(k)
+          end
+
+          self
+        end
+
+        private
+
+        def stringify_keys_recursively!(object)
+          object.extend(StringifyKeys) if object.is_a?(::Hash)
+
+          if object.respond_to?(:stringify_keys!)
+            object.stringify_keys!
+          else
+            object.each{ |o| stringify_keys_recursively!(o) } if object.is_a?(::Array)
+            object
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pdf_tempura/render.rb

@@ -0,0 +1,18 @@
+module PdfTempura
+  module Render
+
+  end
+end
+
+require_relative 'render/option_access'
+require_relative 'render/field_bounds'
+require_relative 'render/debug'
+require_relative 'render/field'
+require_relative 'render/character_field'
+require_relative 'render/text_field'
+require_relative 'render/boxed_characters'
+require_relative 'render/checkbox_field'
+require_relative 'render/field_data_mapper'
+require_relative 'render/page'
+require_relative 'render/table'
+require_relative 'render/field_set'

data/lib/pdf_tempura/render/boxed_characters.rb

@@ -0,0 +1,42 @@
+module PdfTempura
+  module Render
+    class BoxedCharacters
+      include OptionAccess
+      include FieldBounds
+
+      attr_accessor :field,:value
+
+      def initialize(field, value, options = {})
+        @field = field
+        @options = options
+        @value = value ? value.dup : ""
+
+        validate_value_length!
+      end
+
+      def render(pdf)
+        characters = value.chars.to_a
+
+        field.fields.each do |field|
+          break if characters.empty?
+          Field::generate(field, characters.shift, @options).render(pdf)
+        end
+
+        render_debug_annotation(pdf) if draw_outlines?
+      end
+
+      private
+
+      def validate_value_length!
+        if value && !field.truncate? && value.length > field.supported_characters
+          raise ArgumentError.new("Data for #{field.name} must be exactly #{field.supported_characters} characters or use the truncate option.")
+        end
+      end
+
+      def render_debug_annotation(pdf)
+        Debug::OutsideAnnotation.new(field).render(pdf)
+      end
+
+    end
+  end
+end

data/lib/pdf_tempura/render/character_field.rb

@@ -0,0 +1,49 @@
+module PdfTempura
+  module Render
+    class CharacterField < Field
+
+      private
+
+      def set_styling(pdf)
+        pdf.fill_color = "000000"
+        pdf.font @field.font_name, style: font_style
+      end
+
+      def font_style
+        if @field.bold? && @field.italic?
+          :bold_italic
+        elsif @field.bold?
+          :bold
+        elsif @field.italic?
+          :italic
+        else
+          :normal
+        end
+      end
+
+      def render_field(pdf)
+        field_bounds_box(pdf) do
+          padding_bounds_box(pdf) do
+            pdf.text_box(@value.to_s, field_options)
+          end
+        end
+      end
+
+      def field_options
+        {
+          valign: @field.valign.to_sym,
+          align: @field.alignment.to_sym,
+          single_line: !@field.multi_line?,
+          overflow: :shrink_to_fit,
+          size: @field.font_size,
+          leading: @field.leading
+        }
+      end
+
+      def render_debug_annotation(pdf)
+        Debug::CharacterFieldAnnotation.new(@field).render(pdf)
+      end
+
+    end
+  end
+end