pdf_tempura 0.0.2

data/lib/pdf_tempura.rb

@@ -0,0 +1,8 @@
+module PdfTempura
+end
+
+require_relative "pdf_tempura/version"
+require_relative "pdf_tempura/render"
+require_relative "pdf_tempura/renderer"
+require_relative 'pdf_tempura/extensions/hash/stringify_keys'
+require_relative 'pdf_tempura/document'

data/lib/pdf_tempura/document.rb

@@ -0,0 +1,121 @@
+module PdfTempura
+  class Document
+
+    class << self
+
+      def template_file_path
+        @template_file_path
+      end
+
+      def template(path)
+        raise ArgumentError, "Template path must be a string." unless path.is_a?(String)
+        @template_file_path = path
+      end
+
+      def pages
+        @pages ||= []
+      end
+
+      def repeatable
+        @repeatable = true
+      end
+
+      def repeatable_option
+        @repeatable || false
+      end
+
+      def page(page_number, &block)
+        page = Page.new(page_number)
+        pages << page
+        page.instance_eval(&block)
+        nil
+      end
+
+      def debug_options
+        @debug_options ||= []
+      end
+
+      def debug(*options)
+        debug_options.concat options
+      end
+
+    end
+
+    def initialize(data = {})
+      load_data(data)
+    end
+
+    def pages
+      @pages ||= []
+    end
+
+    def render(&block)
+      new_renderer.render(&block)
+    end
+
+    private
+
+    def repeatable
+      self.class.repeatable_option
+    end
+
+    def new_renderer
+      PdfTempura::Renderer.new(
+        self.class.template_file_path,
+        self.pages,
+        {
+          debug: self.class.debug_options,
+          repeatable: self.class.repeatable_option,
+          template_page_count: class_pages.count
+        }
+      )
+    end
+
+    def generate_pages_from_data(data)
+      data.each_with_index do |page_data,number|
+        page = class_pages[number % class_pages.count ]
+
+        self.pages << page.dup.tap{ |new_page|
+          new_page.data = page_data || {}
+        }
+      end
+
+      generate_missing_pages
+    end
+
+    def class_pages
+      self.class.pages
+    end
+
+    def generate_missing_pages
+      if pages.count % class_pages.count != 0
+        [(pages.count % class_pages.count ) .. class_pages.count].each do |number|
+          page = class_pages[number]
+          self.pages << page.dup
+        end
+      end
+    end
+
+    def load_data(data)
+      if !repeatable && data.keys.count > self.class.pages.count
+        raise ArgumentError.new("There are more pages in the data than pages defined.  Use 'repeatable' to repeat template pages in the document class.")
+      end
+
+      keys = data.keys.select{|key| key.kind_of?(Numeric) || key.to_i.to_s == key.to_s}.sort {|key1,key2| key1.to_i <=> key2.to_i}
+      data_for_pages = data.values_at(*keys)
+      generate_pages_from_data(data_for_pages)
+    end
+
+  end
+end
+
+require_relative 'document/validation'
+require_relative 'document/default_commands'
+require_relative 'document/page'
+require_relative 'document/field/base'
+require_relative 'document/character_field'
+require_relative 'document/text_field'
+require_relative 'document/checkbox_field'
+require_relative 'document/table'
+require_relative 'document/boxed_characters'
+require_relative 'document/field_set'

data/lib/pdf_tempura/document/boxed_characters.rb

@@ -0,0 +1,70 @@
+module PdfTempura
+  class Document::BoxedCharacters < Document::Field::Base
+
+    attr_reader :box_width, :box_spacing, :groups, :truncate, :text_options, :padding
+    attr_accessor :coordinates
+    alias :truncate? :truncate
+
+    validates :box_width, required: true, type: Numeric
+    validates :box_spacing, required: true, type: Numeric
+    validates :truncate, boolean: true
+
+    def initialize(name, coordinates, height, options = {}, &block)
+      @groups = []
+
+      super name, coordinates, [0, height], options
+
+      instance_eval(&block) if block_given?
+    end
+
+    def characters(characters)
+      @groups << CharacterGroup.new(characters)
+    end
+
+    def space(width)
+      @groups << SpaceGroup.new(width)
+    end
+
+    def supported_characters
+      @groups.map(&:characters).inject(:+)
+    end
+
+    def fields
+      @fields ||= generate_text_fields
+    end
+
+    def width
+      groups.inject(0){ |sum,group| sum + group.width(box_width, box_spacing) }
+    end
+
+    def dimensions
+      [width, @dimensions[1]]
+    end
+
+    private
+
+    def generate_text_fields
+      [].tap do |fields|
+        groups.inject(self.x) do |x, group|
+          group.each_supported_character do
+            fields << Document::CharacterField.new(name, [x,y], [box_width,height], text_options)
+            x+= box_width + box_spacing
+          end
+
+          x + group.spacing - (group.characters > 0 ? box_spacing : 0)
+        end
+      end
+    end
+
+    def load_options(options)
+      @box_width = options["box_width"]
+      @box_spacing = options["box_spacing"]
+      @truncate = options["truncate"] || false
+      @text_options = options.reject { |key,v| ["box_width", "box_spacing", "truncate"].include?(key) }
+      @padding = [0,0,0,0]
+    end
+
+  end
+end
+
+require_relative 'boxed_characters/groups'

data/lib/pdf_tempura/document/boxed_characters/groups.rb

@@ -0,0 +1,53 @@
+module PdfTempura
+  class Document::BoxedCharacters::CharacterGroup
+    include Document::Validation
+
+    attr_reader :characters
+
+    validates :characters, type: Numeric
+
+    def initialize(characters)
+      @characters = characters
+      validate!
+    end
+
+    def spacing
+      0
+    end
+
+    def each_supported_character(&block)
+      characters.times{ yield }
+    end
+
+    def width(box_width, spacing)
+      box_width * characters + spacing * (characters - 1)
+    end
+
+  end
+
+  class Document::BoxedCharacters::SpaceGroup
+    include Document::Validation
+
+    attr_reader :spacing
+
+    validates :spacing, type: Numeric
+
+    def initialize(units)
+      @spacing = units
+      validate!
+    end
+
+    def characters
+      0
+    end
+
+    def each_supported_character(&block)
+      #we support no characters, nein!
+    end
+
+    def width(ignored,ignored2)
+      spacing
+    end
+
+  end
+end

data/lib/pdf_tempura/document/character_field.rb

@@ -0,0 +1,37 @@
+module PdfTempura
+  class Document::CharacterField < Document::Field::Base
+
+    attr_reader :default_value, :font_name, :font_size, :bold, :italic, :padding,
+      :alignment, :multi_line, :valign, :leading
+
+    alias_method :bold?, :bold
+    alias_method :italic?, :italic
+    alias_method :multi_line?, :multi_line
+
+    validates :font_name, type: String
+    validates :font_size, type: Numeric
+    validates :bold, inclusion: [true, false]
+    validates :italic, inclusion: [true, false]
+    validates :alignment, inclusion: ["left", "right", "center"]
+    validates :multi_line, inclusion: [true, false]
+    validates :padding, type: Array, inner_type: Numeric, count: 4
+    validates :default_value, type: String
+
+    private
+
+    def load_options(options)
+      @default_value = options["default_value"] || ""
+      @font_name = options["font_name"] || "Helvetica"
+      @font_size = options["font_size"] || 10
+      @bold = options["bold"] || false
+      @italic = options["italic"] || false
+      @bold = options["bold"] || false
+      @padding = options["padding"] || [0,0,0,0]
+      @alignment = "center"
+      @multi_line = false
+      @valign = "center"
+      @leader = 0
+    end
+
+  end
+end

data/lib/pdf_tempura/document/checkbox_field.rb

@@ -0,0 +1,15 @@
+module PdfTempura
+  class Document::CheckboxField < Document::Field::Base
+
+    attr_reader :default_value, :padding
+
+    validates :default_value, inclusion: [true, false]
+    validates :padding, type: Array, inner_type: Numeric, count: 4
+
+    def load_options(options)
+      @default_value = options["default_value"] || false
+      @padding = options["padding"] || [1,1,1,1]
+    end
+
+  end
+end

data/lib/pdf_tempura/document/default_commands.rb

@@ -0,0 +1,40 @@
+module PdfTempura
+  module Document::DefaultCommands
+
+    def self.included(base)
+      base.send(:attr_accessor, :fields)
+    end
+
+    def text_field(name, coordinates, dimensions, options = {})
+      fields << Document::TextField.new(name, coordinates, dimensions, @options.merge(options))
+    end
+
+    def checkbox_field(name, coordinates, dimensions, options = {})
+      fields << Document::CheckboxField.new(name, coordinates, dimensions, @options.merge(options))
+    end
+
+    def table(name, coordinates, options = {}, &block)
+      fields << Document::Table.new(name, coordinates, @options.merge(options), &block)
+    end
+
+    def boxed_characters(name, coordinates, height, options = {}, &block)
+      fields << Document::BoxedCharacters.new(name, coordinates, height, @options.merge(options), &block)
+    end
+
+    def field_set(name, options = {}, &block)
+      fields << Document::FieldSet.new(name, @options.merge(options), &block)
+    end
+
+    def with_default_options(options = {}, &block)
+      previous_options = @options
+
+      begin
+        @options = @options.merge(options)
+        instance_eval(&block)
+      ensure
+        @options = previous_options
+      end
+    end
+
+  end
+end

data/lib/pdf_tempura/document/field/base.rb

@@ -0,0 +1,55 @@
+module PdfTempura
+  module Document::Field
+    class Base
+      include Document::Validation
+
+      def initialize(name, coordinates, dimensions, options = {})
+        @name = name.is_a?(Symbol) ? name.to_s : name
+        @coordinates = coordinates
+        @dimensions = dimensions
+
+        convert_options_hash(options)
+        load_options(options)
+
+        validate!
+      end
+
+      attr_reader :name, :coordinates, :dimensions
+
+      validates :name, type: String
+      validates :coordinates, type: Array, inner_type: Numeric, count: 2
+      validates :dimensions, type: Array, inner_type: Numeric, count: 2
+
+      def x
+        coordinates.first
+      end
+
+      def y
+        coordinates.last
+      end
+
+      def width
+        dimensions.first
+      end
+
+      def height
+        dimensions.last
+      end
+
+      private
+
+      def load_options(options)
+        raise NotImplementedError, "Implement 'load_options' in your subclass."
+      end
+
+      def convert_options_hash(options)
+        if options.is_a?(Hash)
+          options.extend(Extensions::Hash::StringifyKeys).stringify_keys!
+        else
+          raise ArgumentError, "Options must be a hash."
+        end
+      end
+
+    end
+  end
+end

data/lib/pdf_tempura/document/field_set.rb

@@ -0,0 +1,51 @@
+module PdfTempura
+  class Document::FieldSet
+    include Document::Validation
+    include Document::DefaultCommands
+
+    attr_reader :name
+
+    validates :name, type: String
+
+    def initialize(name, options = {}, &block)
+      @name = name
+      @fields = []
+      @options = options
+
+      instance_eval(&block) if block_given?
+      validate!
+    end
+
+    def coordinates
+      [x,y]
+    end
+
+    def dimensions
+      [width,height]
+    end
+
+    def x
+      fields.map(&:x).min || 0
+    end
+
+    def y
+      fields.map(&:y).max || 0
+    end
+
+    def width
+      return 0 if fields.empty?
+      fields.map{ |field| field.x + field.width }.max - x
+    end
+
+    def height
+      return 0 if fields.empty?
+      y - fields.map{ |field| field.y - field.height }.min
+    end
+
+    def padding
+      [0,0,0,0]
+    end
+
+  end
+end
+