clockworkcomicpdf 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 983d2f02eac2ae6b01baf045ccae832effa3ae3a
+  data.tar.gz: 565431e7815bcfd34301b89b45b3b6873cb8a0a6
+SHA512:
+  metadata.gz: 034150b51ff58647e31ba36f77a0916bd3290984e153fffcaca1b8c3acac180a4f2b4f57d3abc29d961efd9dd356d77220b3cd2e877d8cf42a3971a4a9e1502a
+  data.tar.gz: 0a6aefc0b8080189f0b6a9e57c12b5a3126d1c398531e1805856717f2a0589821760d613a95553b4e795a5005d047caf58e8ccd4fb40c062ebbe3a232e2aab22

data/lib/clockwork_comic_pdf/book.rb

@@ -0,0 +1,102 @@
+require_relative 'to_points'
+require_relative 'page_header'
+require_relative 'errors'
+require_relative 'cover'
+require_relative 'version'
+require_relative 'option_validation'
+require_relative 'book_validation'
+require_relative 'book_init'
+
+module ClockworkComicPDF
+  # variable storage for the book class
+  class Book
+    include OptionValidation, BookValidation, BookInit
+    def font
+      @font ||= 'Helvetica'
+    end
+    attr_writer :font
+
+    def font_size
+      @font_size ||= 12
+    end
+
+    def font_size=(font_size)
+      @font_size = font_size.to_points unless font_size.nil?
+    end
+
+    attr_accessor :base_file_name
+
+    def info
+      @info ||= {}
+    end
+
+    def info=(info)
+      if info.is_a? Hash
+        info[:CreationDate] = Time.now
+        info[:Creator] = 'Clockwork Comic PDF Engine'
+        info[:Producer] = 'Prawn'
+      else
+        fail InvalidValueError, 'Information must be set as a Hash value'
+      end
+      @info = info
+    end
+
+    def page_size
+      @page_size ||= [{ val: 8.5, type: :in },
+                      { val: 11, type: :in }]
+    end
+
+    def page_size=(page_size)
+      page_size = page_size.to_a
+      page_size.each do |dim|
+        page_size[page_size.find_index dim] = dim.to_points
+      end
+      @page_size = page_size
+    end
+
+    def margin
+      @margin ||= { val: 0.25, type: :in }
+    end
+
+    def margin=(margin)
+      @margin = []
+      margin = [margin] unless margin.is_a? Array
+      unless margin.count == 4 || margin.count == 1
+        fail InvalidValueError 'Margin must contain 1 or 4 values'
+      end
+      margin.each_index do |i|
+        @margin[i] = margin[i].to_points
+      end
+      @margin
+    end
+
+    def offset_from_spine
+      @offset_from_spine ||= 0
+    end
+
+    def offset_from_spine=(offset_from_spine)
+      @offset_from_spine = offset_from_spine.to_points
+    end
+
+    def print_toc
+      @print_toc = true if @print_toc.nil?
+      @print_toc
+    end
+    attr_writer :print_toc
+
+    def print_pagenum
+      @print_pagenum = true if @print_toc.nil?
+      @print_pagenum
+    end
+    attr_writer :print_pagenum
+    attr_accessor :page_header
+    attr_accessor :cover
+
+    def versions
+      @versions ||= []
+    end
+    attr_writer :versions
+
+    attr_accessor :sections
+  end
+end

data/lib/clockwork_comic_pdf/book_init.rb

@@ -0,0 +1,37 @@
+module ClockworkComicPDF
+  # initalization blocks for the book class
+  module BookInit
+    def valid_options
+      [:font, :info, :base_file_name, :page_size, :margin,
+       :offset_from_spine, :print_toc, :print_pagenum, :page_header,
+       :versions, :sections, :font_size, :cover]
+    end
+
+    def initialize(options = {})
+      check_options(options.keys, valid_options)
+      initialize_options(options)
+      initialize_content(options)
+    end
+
+    private
+
+    def initialize_options(options = {})
+      self.font = options[:font]
+      self.base_file_name = options[:base_file_name]
+      self.info = options[:info]
+      self.page_size = options[:page_size]
+      self.margin = options[:margin]
+      self.offset_from_spine = options[:offset_from_spine]
+      self.print_toc = options[:print_toc]
+      self.print_pagenum = options[:print_pagenum]
+    end
+
+    def initialize_content(options = {})
+      self.page_header = PageHeader.new(options[:page_header])
+      self.cover = Cover.new(options[:cover])
+      self.versions = Versions.new(options[:versions])
+      self.sections = Sections.new(options[:sections])
+      self.font_size = options[:font_size]
+    end
+  end
+end

data/lib/clockwork_comic_pdf/book_validation.rb

@@ -0,0 +1,79 @@
+module ClockworkComicPDF
+  # Validation Module for Book Class
+  module BookValidation
+    def validate
+      fail MissingValueError, 'base_file_name required' unless @base_file_name
+      cover.validate if cover
+      sections.validate
+      versions.validate
+      miss = image_mismatch
+      if miss.count > 0
+        fail_s = "Image directories do no match: #{miss.join(', ')}"
+        fail MissingValueError, fail_s
+      end
+    end
+
+    def image_mismatch
+      mismatch = []
+      files = version_files
+      files.each_pair do |key_v, sec|
+        mismatch.concat(scan_version(key_v, sec, files))
+      end
+      mismatch.flatten
+    end
+
+    def scan_version(key_v, sec, files)
+      mismatch = []
+      files.each_pair do |c_ver, c_sec|
+        unless key_v == c_ver
+          mismatch << scan_section(key_v.name, sec, c_ver.name, c_sec)
+        end
+      end
+      mismatch
+    end
+
+    def scan_section(v_name, sec_v, c_name, sec_c)
+      mismatch = []
+      sec_v.each_pair do |ss_key, ss_v|
+        ss_v.each do |f|
+          unless sec_c[ss_key].include? f
+            mismatch << "#{f} in section #{ss_key.name} exists " <<
+                        "in #{v_name} but not #{c_name}"
+          end
+        end
+      end
+      mismatch
+    end
+
+    def version_files
+      files = {}
+      versions.each do |version|
+        files[version] = section_files(version)
+      end
+      files
+    end
+
+    def section_files(check_ver)
+      s_files = {}
+      [sections.front_matter, sections.body,
+       sections.end_matter].flatten.each do |sub|
+        if sub.is_a? SectionComicPages
+          s_files[sub] = get_comic_files(check_ver, sub)
+        end
+      end
+      s_files
+    end
+
+    def get_comic_files(check_ver, sub)
+      current_dir = "./#{check_ver.name}/#{sub.directory}/"
+      unless File.exist?(current_dir)
+        fail InvalidValueError, "#{File.path(current_dir)} does not exist"
+      end
+      c_files = []
+      Dir["#{current_dir}*.*"].each do |file|
+        c_files << File.basename(file, '.*')
+      end
+      c_files
+    end
+  end
+end

data/lib/clockwork_comic_pdf/cover.rb

@@ -0,0 +1,42 @@
+require_relative 'to_points'
+require_relative 'errors'
+require_relative 'option_validation'
+
+module ClockworkComicPDF
+  # this contains the size, file path, and size of the cover
+  class Cover
+    include OptionValidation
+    attr_reader :size
+    def size=(size)
+      unless size.is_a?(Array) && size.count == 2
+        throw InvalidValueError.new 'Cover size must contain exactly 2 values'
+      end
+      size[0] = size[0].to_points
+      size[1] = size[1].to_points
+      @size = size
+    end
+
+    attr_reader :path
+    def path=(path)
+      @path = path.to_s
+    end
+
+    attr_reader :file
+    def file=(file)
+      @file = file.to_s
+    end
+
+    def validate
+      fail InvalidValueError, 'Cover Must specify a file' unless file
+      fail InvalidValueError, 'Cover must specify a size' unless size
+      fail InvalidValueError, 'Cover must specify a path' unless path
+    end
+
+    def initialize(options = {})
+      check_options(options.keys, [:size, :path, :file])
+      self.path = options[:path]
+      self.size = options[:size]
+      self.file = options[:file]
+    end
+  end
+end

data/lib/clockwork_comic_pdf/errors.rb

@@ -0,0 +1,13 @@
+module ClockworkComicPDF
+  class MissingValueError < StandardError
+  end
+
+  class InvalidValueError < ArgumentError
+  end
+
+  class UndefinedKeyError < ArgumentError
+  end
+
+  class ArgumentError < ArgumentError
+  end
+end

data/lib/clockwork_comic_pdf/measurement_parser.rb

@@ -0,0 +1,83 @@
+module ClockworkComicPDF
+  # stores the option parsing logic for PDFMaker
+  module MeasurementParser
+    def parse_options(pdf, opt_in)
+      out = {}
+      opt_in.each_pair do |key, val|
+        case key
+        when :height_ratio then out[:height] = pdf.bounds.height * val.to_r
+        when :width_ratio then out[:width] = pdf.bounds.width * val.to_r
+        else out[key] = convert_val(pdf, val, opt_in)
+        end
+      end
+      out
+    end
+
+    def convert_val(pdf, val, opt_in)
+      if val.is_a? Array
+        val = Array.new(val)
+        val.each_index do |i|
+          val[i] = convert_val(pdf, val[i], opt_in)
+        end
+      else
+        val = convert_position(pdf, val)
+        val = convert_size(pdf, val, opt_in)
+      end
+      val
+    end
+
+    def convert_position(pdf, val)
+      val = convert_complex_position(pdf, val)
+      val = convert_simple_position(pdf, val)
+      val
+    end
+
+    def convert_complex_position(pdf, val)
+      case val
+      when :bounds_top_left then return pdf.bounds.top_left
+      when :bounds_top_right then return pdf.bounds.top_right
+      when :bounds_bottom_left then return pdf.bounds.bottom_left
+      when :bounds_bottom_right then return pdf.bounds.bottom_right
+      else return val
+      end
+    end
+
+    def convert_simple_position(pdf, val)
+      case val
+      when :bounds_top then return pdf.bounds.top
+      when :bounds_bottom then return pdf.bounds.bottom
+      when :bounds_left then return pdf.bounds.left
+      when :bounds_right then return pdf.bounds.right
+      else return val
+      end
+    end
+
+    def convert_size(pdf, val, opt_in)
+      case val
+      when :bounds_width then return pdf.bounds.width
+      when :bounds_height then return pdf.bounds.height
+      when :bounds_center_width then return get_h_center(pdf, opt_in)
+      when :bounds_center_height then return get_v_center(pdf, opt_in)
+      else return val
+      end
+    end
+
+    def get_h_center(pdf, opt_in)
+      if !opt_in[:width_ratio].nil?
+        box_width = opt_in[:width_ratio].to_r * pdf.bounds.width
+      else
+        box_width = opt_in[:width]
+      end
+      pdf.bounds.width / 2 - box_width / 2
+    end
+
+    def get_v_center(pdf, options)
+      if !opt_in[:height_ratio].nil?
+        box_height = opt_in[:height_ratio].to_r * pdf.bounds.height
+      else
+        box_height = opt_in[:height]
+      end
+      pdf.bounds.height / 2 - box_height / 2
+    end
+  end
+end

data/lib/clockwork_comic_pdf/option_validation.rb

@@ -0,0 +1,23 @@
+require_relative 'errors'
+
+# Module-level parameter checker
+module ClockworkComicPDF
+  # provides option validation and requirements vaildaiton
+  module OptionValidation
+    def check_options(options, valid_options)
+      options.each do |key|
+        unless valid_options.include? key
+          fail UndefinedKeyError, "Unsupported key '#{key}' " <<
+                                  "for '#{self.class}'"
+        end
+      end
+    end
+
+    def check_required(options = {})
+      options.each_pair do |key, val|
+        fail UndefinedKeyError, "'#{self.class}' requires " <<
+                                "key '#{key}'" if val.nil?
+      end
+    end
+  end
+end

data/lib/clockwork_comic_pdf/page_header.rb

@@ -0,0 +1,59 @@
+require_relative 'errors'
+require_relative 'option_validation'
+
+module ClockworkComicPDF
+  # storage class for the page header
+  # includes alignment, left and right side text, and size
+  class PageHeader
+    include OptionValidation
+    def align
+      @align = :center unless @align
+      @align
+    end
+    attr_writer :align
+
+    def text=(text)
+      self.left_text = text
+      self.right_text = text
+    end
+
+    def text
+      { left: left_text, right: right_text }
+    end
+
+    def left_text
+      @left_text ||= ''
+    end
+
+    def left_text=(left_text)
+      @left_text = left_text.to_s
+    end
+
+    def right_text
+      @right_text ||= ''
+    end
+
+    def right_text=(right_text)
+      @right_text = right_text.to_s
+    end
+
+    def size
+      @size = 8 unless @size
+      @size
+    end
+
+    def size=(size)
+      @size = size.to_points
+    end
+
+    def initialize(options = {})
+      valid_options = [:size, :text, :left_text, :right_text, :align]
+      check_options(options.keys, valid_options)
+      self.size = options[:size]
+      self.text = options[:text]
+      self.left_text = options[:left_text]
+      self.right_text = options[:right_text]
+      self.align = options[:align]
+    end
+  end
+end

data/lib/clockwork_comic_pdf/pdf_maker.rb

@@ -0,0 +1,116 @@
+require_relative 'book'
+require_relative 'version'
+require_relative 'measurement_parser'
+require_relative 'pdf_section_maker'
+require_relative 'pdf_toc_maker'
+require 'prawn'
+
+module ClockworkComicPDF
+  # this parses the sections of a book into a pdf file
+  class PDFMaker
+    include MeasurementParser, PDFSectionMaker, PDFTocMaker
+    attr_accessor :book, :content_start, :debug, :printing_body, :current_page,
+                  :trim_offset
+
+    attr_writer :page_index
+    def page_index
+      @page_index ||= []
+    end
+
+    def initialize(book)
+      self.book = book
+    end
+
+    def print
+      book.validate
+      book.versions.each do |version|
+        self.content_start = nil
+        self.printing_body = false
+        self.current_page = nil
+        self.page_index = nil
+        self.debug = false
+        print_version(version)
+      end
+    end
+
+    def print_version(version)
+      self.trim_offset = version.trim_offset
+      pdf = Prawn::Document.new(info: book.info, font_size: book.font_size,
+                                skip_page_creation: true)
+      print_sections(pdf, version)
+      print_cover(pdf, version) if version.print_cover
+      pdf.render_file "#{book.base_file_name} - #{version.name}.pdf"
+    end
+
+    def print_cover(pdf, version)
+      pdf.go_to_page 0
+      return if book.cover.nil?
+      cover = book.cover
+      pdf.start_new_page(size: cover.size, margin: 0)
+      pdf.image("#{cover.path}/#{version.name}/#{cover.file}",
+                at: pdf.bounds.top_left, scale: 72.0 / version.dpi.to_f)
+    end
+
+    def new_page(pdf)
+      if trim_offset then make_trim_page(pdf)
+      else make_offset_page(pdf)
+      end
+      pdf.font(book.font)
+      print_body_page(pdf) if printing_body
+      debug_stroke(pdf) if debug
+    end
+
+    def make_offset_page(pdf)
+      margin = Array.new(book.margin)
+      if pdf.page_number.odd? then margin[1] += book.offset_from_spine
+      else margin[3] += book.offset_from_spine
+      end
+      pdf.start_new_page(size: book.page_size, margin: margin)
+    end
+
+    def make_trim_page(pdf)
+      margin = Array.new(book.margin)
+      pdf.start_new_page(size: [book.page_size[0] - book.offset_from_spine,
+                                book.page_size[1]],
+                         margin: margin)
+    end
+
+    def print_body_page(pdf)
+      self.current_page += 1
+      print_header(pdf) unless book.page_header.nil?
+      print_page_num(pdf) if book.print_pagenum
+    end
+
+    def print_header(pdf)
+      head = book.page_header
+      options = { size: head.size, align: head.align, width: pdf.bounds.width }
+      text = pdf.page_number.even? ? head.left_text : head.right_text
+      options[:at] = [pdf.bounds.left, pdf.bounds.top + 0.25.in]
+      options[:valign] = :center
+      options[:height] = 0.25.in
+      if options[:align] == :alternating
+        options[:align] = even_page ? :left : :right
+      end
+      pdf.text_box(text, options)
+    end
+
+    def print_page_num(pdf)
+      options = { at: pdf.bounds.bottom_left,
+                  width: pdf.bounds.width,
+                  align: :center,
+                  size: 8 }
+      options[:height] = 0.25.in
+      pdf.text_box("#{self.current_page}", options)
+    end
+
+    def debug_stroke(pdf)
+      pdf.stroke_bounds
+      pdf.stroke do
+        pdf.line [0, 0], [pdf.bounds.width, pdf.bounds.height]
+        pdf.line [pdf.bounds.width, 0], [0, pdf.bounds.height]
+        pdf.line  [pdf.bounds.width / 2,
+                   pdf.bounds.height], [pdf.bounds.width / 2, 0]
+      end
+    end
+  end
+end

data/lib/clockwork_comic_pdf/pdf_section_maker.rb

@@ -0,0 +1,82 @@
+module ClockworkComicPDF
+  # this parses the sections of a book into a pdf file
+  module PDFSectionMaker
+    def print_sections(pdf, version)
+      print_section(pdf, version, book.sections.front_matter)
+      self.printing_body = true
+      self.current_page = 0
+      self.content_start = pdf.page_number + 1
+      print_section(pdf, version, book.sections.body)
+      self.printing_body = false
+      print_section(pdf, version, book.sections.end_matter)
+      new_page(pdf) if pdf.page_number.odd?
+      print_toc(pdf) if book.print_toc
+    end
+
+    def print_section(pdf, version, section)
+      section.each do |item|
+        case item.type
+        when :text_box
+          print_text_box(pdf, version, item)
+        when :formatted_text_box
+          print_formatted_text_box(pdf, version, item)
+        when :comic_pages
+          print_comic_pages(pdf, version, item)
+        end
+      end
+    end
+
+    def print_comic_pages(pdf, version, comic_pages)
+      puts comic_pages.name
+      if comic_pages.print_section_intro
+        print_section_break(pdf, comic_pages.name)
+      end
+      section_dir = "./#{version.name}/#{comic_pages.directory}/"
+      Dir["#{section_dir}*.*"].each do |image|
+        print_comic_image(pdf, version, image)
+      end
+    end
+
+    def print_section_break(pdf, text)
+      new_page(pdf)
+      pdf.move_cursor_to pdf.bounds.top
+      options = { valign: :center, align: :center, width: pdf.bounds.width,
+                  height: pdf.bounds.height, size: 18,
+                  at: pdf.bounds.top_left }
+      page_index << { page: current_page, name: text } if printing_body
+      pdf.text_box(text, options)
+    end
+
+    def print_comic_image(pdf, version, image)
+      new_page(pdf)
+      name = make_name(image)
+      page_index << { page: current_page, name: "#{name}" } if printing_body
+      content = [[name], [{ image: image, scale: 72.0 / version.dpi }]]
+      table = Prawn::Table.new(content, pdf, cell_style: { borders: [] },
+                                             position: :center)
+      pdf.move_down((pdf.bounds.height - table.height) / 2.0)
+      table.draw
+    end
+
+    def make_name(file_path)
+      File.basename(file_path, '.*').split(' ').slice(1..-1).join(' ')
+    end
+
+    def print_text_box(pdf, version, content)
+      text = File.new(content.file).read
+      make_text_box(pdf, [{ text: text }], content)
+    end
+
+    def print_formatted_text_box(pdf, version, content)
+      text = YAML.load_file(content.file)
+      make_text_box(pdf, text, content)
+    end
+
+    def make_text_box(pdf, text, content)
+      new_page(pdf)
+      page_index << { page: current_page, name: content.name } if printing_body
+      options = parse_options(pdf, content.options)
+      pdf.formatted_text_box(text, options)
+    end
+  end
+end

data/lib/clockwork_comic_pdf/pdf_toc_maker.rb

@@ -0,0 +1,27 @@
+module ClockworkComicPDF
+  # stores the PDF printing methods for making the table of contents
+  module PDFTocMaker
+    def print_toc(pdf)
+      pdf.go_to_page(content_start - 1)
+      toc_start = pdf.page_number
+      new_page(pdf)
+      pdf.text 'Table of Contents', size: 18, align: :left
+      pdf.move_down(25)
+      page_index.each { |toc_item| make_toc_item(pdf, toc_item) }
+      new_page(pdf) unless (toc_start - pdf.page_number).even?
+      self.content_start += (toc_start - pdf.page_number)
+    end
+
+    def make_toc_item(pdf, toc_item)
+      content = [["#{toc_item[:name]}", "#{toc_item[:page]}"]]
+      options = { width: pdf.bounds.width / 2, position: :center,
+                  cell_style: { borders: [], size: 8,
+                                padding: 1 } }
+      table = Prawn::Table.new(content, pdf, options) do
+        cells.style { |c| c.align = c.column.zero? ? :left : :right }
+      end
+      new_page(pdf) if table.height >= pdf.cursor
+      table.draw
+    end
+  end
+end

data/lib/clockwork_comic_pdf/section.rb

@@ -0,0 +1,144 @@
+require_relative 'option_validation'
+
+module ClockworkComicPDF
+  # this stores the data for each section of the book
+  class Sections
+    include OptionValidation
+    def front_matter
+      @front_matter ||= []
+    end
+    attr_writer :front_matter
+
+    def body
+      @body ||= []
+      @body
+    end
+    attr_writer :body
+
+    def end_matter
+      @end_matter ||= []
+      @end_matter
+    end
+    attr_writer :end_matter
+
+    def parse_sections(sections)
+      parsed_sections = []
+      sections.each do |section|
+        parsed_sections << section_by_type(section)
+      end
+      parsed_sections
+    end
+
+    def section_by_type(section)
+      case section[:type]
+      when :comic_pages
+        return SectionComicPages.new(section)
+      when :text_box
+        return SectionTextBox.new(section)
+      when :formatted_text_box
+        return SectionFormattedTextBox.new(section)
+      else
+        fail InvalidKeyError, "#{section[:type]} is not a valid section type"
+      end
+    end
+
+    def validate
+      [front_matter, body, end_matter].each do |chunk|
+        chunk.each { |sec| sec.validate }
+      end
+    end
+
+    def print_pdf(options = {})
+      [front_matter, body, end_matter].each do |chunk|
+        chunk.each { |sec| sec.print_pdf(options) }
+      end
+    end
+
+    def initialize(options = {})
+      check_options(options.keys, [:front_matter, :body, :end_matter])
+      self.front_matter = parse_sections(options[:front_matter])
+      self.body = parse_sections(options[:body])
+      self.end_matter = parse_sections(options[:end_matter])
+    end
+  end
+
+  # this is the base class for sections data that stores common section info
+  class Section
+    include OptionValidation
+    attr_writer :print_section_intro
+    def print_section_intro
+      @print_section_intro = false if @print_section_intro.nil?
+      @print_section_intro
+    end
+
+    attr_accessor :type
+    attr_accessor :name
+
+    def valid_options
+      @valid_options = [:print_section_intro, :type, :name]
+    end
+
+    def req_keys
+      @required_keys = { name: @name }
+    end
+
+    def validate
+      check_required(req_keys)
+    end
+
+    def initialize(options = {})
+      self.name = options[:name]
+      self.type = options[:type]
+      self.print_section_intro = options[:print_section_intro]
+    end
+  end
+
+  # Comic Pages section
+  class SectionComicPages < Section
+    def valid_options
+      super
+      @valid_options << :directory
+    end
+
+    def req_keys
+      super
+      @required_keys[:directory] = @directory
+      @required_keys
+    end
+
+    attr_accessor :directory
+
+    def initialize(options = {})
+      super
+      self.directory = options[:directory]
+    end
+  end
+
+  # text box method
+  class SectionTextBox < Section
+    attr_accessor :file, :options
+
+    def valid_options
+      super
+      @valid_options << :file
+      @valid_options << :options
+    end
+
+    def req_keys
+      super
+      @required_keys[:file] = @file
+      @required_keys[:options] = @options
+      @required_keys
+    end
+
+    def initialize(options = {})
+      super
+      self.options = options[:options]
+      self.file = options[:file]
+    end
+  end
+
+  # formatted text box method
+  class SectionFormattedTextBox < SectionTextBox
+  end
+end

data/lib/clockwork_comic_pdf/to_points.rb

@@ -0,0 +1,27 @@
+require 'prawn/measurement_extensions'
+
+# adds point conversion function for hash values
+class Hash
+  def to_points
+    if size == 2 && self[:val] && self[:type]
+      return self[:val].to_f.send(self[:type])
+    end
+    puts self
+    fail ClockworkComicPDF::UndefinedKeyError,
+         'measurement must contain only :val and :type'
+  end
+end
+
+# returns itself as is for fixnum
+class Fixnum
+  def to_points
+    self
+  end
+end
+
+# returns itself as is for Float
+class Float
+  def to_points
+    self
+  end
+end

data/lib/clockwork_comic_pdf/version.rb

@@ -0,0 +1,59 @@
+require_relative 'option_validation'
+
+module ClockworkComicPDF
+  # convienience class for parsing and holding version objects
+  class Versions < Array
+    def initialize(options)
+      options.each do |param|
+        self << Version.new(param)
+      end
+    end
+
+    def validate
+      each { |version| version.validate }
+    end
+  end
+
+  # stores version information for PDF generation
+  # includes name, length, dpi and a toggle for printing the cover
+  class Version
+    include OptionValidation
+    attr_reader :name
+    def name=(name)
+      @name = name.to_s
+    end
+
+    attr_reader :dpi
+    def dpi=(dpi)
+      @dpi = dpi.to_i
+    end
+
+    def print_cover
+      @print_cover = false if @print_cover.nil?
+      @print_cover
+    end
+    attr_writer :print_cover
+
+    def trim_offset
+      @trim_offset = false if @trim_offset.nil?
+      @trim_offset
+    end
+    attr_writer :trim_offset
+
+    def validate
+      fail InvalidValueError, 'Each version must contain a name' unless name
+      fail InvalidValueError,
+           'Each version must contain a name' if name.length == 0
+      fail InvalidValueError,
+           'each version must specify a dpi value' unless dpi
+    end
+
+    def initialize(options = {})
+      check_options(options.keys, [:name, :dpi, :print_cover, :trim_offset])
+      self.name = options[:name]
+      self.dpi = options[:dpi]
+      self.trim_offset = options[:trim_offset]
+      self.print_cover = options[:print_cover]
+    end
+  end
+end

data/lib/clockworkcomicpdf.rb

@@ -0,0 +1,21 @@
+require 'prawn'
+require 'yaml'
+
+require_relative 'clockwork_comic_pdf/book'
+require_relative 'clockwork_comic_pdf/errors'
+require_relative 'clockwork_comic_pdf/page_header'
+require_relative 'clockwork_comic_pdf/cover'
+require_relative 'clockwork_comic_pdf/version'
+require_relative 'clockwork_comic_pdf/section'
+require_relative 'clockwork_comic_pdf/option_validation'
+require_relative 'clockwork_comic_pdf/pdf_maker'
+
+# the base module for ClockworkComicPDF
+module ClockworkComicPDF
+  # VERSION "0.1.0"
+  def book_from_yaml(book)
+    parsed_book = Book.new(YAML.load_file(book))
+    PDFMaker.new(parsed_book).print
+  end
+  module_function :book_from_yaml
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: clockworkcomicpdf
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Skiba
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.15.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.15.0
+description: A Simple(ish) Ruby System for creating print and web ready PDF files.
+email: mike.skiba@atelierclockwork.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/clockwork_comic_pdf/book.rb
+- lib/clockwork_comic_pdf/book_init.rb
+- lib/clockwork_comic_pdf/book_validation.rb
+- lib/clockwork_comic_pdf/cover.rb
+- lib/clockwork_comic_pdf/errors.rb
+- lib/clockwork_comic_pdf/measurement_parser.rb
+- lib/clockwork_comic_pdf/option_validation.rb
+- lib/clockwork_comic_pdf/page_header.rb
+- lib/clockwork_comic_pdf/pdf_maker.rb
+- lib/clockwork_comic_pdf/pdf_section_maker.rb
+- lib/clockwork_comic_pdf/pdf_toc_maker.rb
+- lib/clockwork_comic_pdf/section.rb
+- lib/clockwork_comic_pdf/to_points.rb
+- lib/clockwork_comic_pdf/version.rb
+- lib/clockworkcomicpdf.rb
+homepage: http://www.atelierclockwork.net/ccpdf/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Clockwork Comic PDF
+test_files: []