bread-basket 0.0.0 → 0.0.1

data/lib/bread/basket/poster/image_box.rb

@@ -0,0 +1,93 @@
+module Bread
+  module Basket
+    module Poster
+      class ImageBox < Box
+        attr_reader :size
+        attr_accessor :box_width, :box_height, :im_width, :im_height
+        def setup_dimensions
+          image_specs
+          handle_width_and_height
+          DimensionsHelper.new(self, layout, specs)
+          layout.pending << selector_name unless pending.empty?
+        end
+
+        def image_specs
+          image_path = Bread::Basket::Poster.dir_path + '/' + specs['src']
+          @size = FastImage.size image_path
+          read_fail(image_path) if size.nil?
+          # TODO: Learn how printing resolution in images works with prawn
+          # update: it's complicated!
+        end
+
+        def handle_width_and_height
+          if specs['width'] || specs['height']
+            # shuffle values around for fitting
+            fitted_width_and_height
+          else
+            specs['width'] = size[0]
+            specs['height'] = size[1]
+          end
+        end
+
+        def fitted_width_and_height
+          # set width and height from size if missing from css
+          find_width_height
+          # store these values as specifying the container's size, not
+          # the image's actual final size
+          specs['box_width'] = specs['width']
+          specs['box_height'] = specs['height']
+          # now use css notation to make this dependent on its own fitting so
+          # that other Dimensions Mechanics can handle this normally
+          specs['width'] = "#{method_name}.im_width"
+          specs['height'] = "#{method_name}.im_height"
+        end
+
+        def find_width_height
+          specs['width'] ||= size[0]
+          specs['height'] ||= size[1]
+        end
+
+        def try_to_resolve
+          if box_width.is_a?(Numeric) && box_height.is_a?(Numeric)
+            fit_width_and_height
+          end
+          super
+        end
+
+        def fit_width_and_height
+          if im_ratio > box_ratio
+            w = box_width
+            h = box_width / im_ratio
+          else
+            h = box_height
+            w = box_height * im_ratio
+          end
+          add_to_determined('im_width', w)
+          add_to_determined('im_height', h)
+        end
+
+        def box_ratio
+          box_width / box_height.to_f
+        end
+
+        def im_ratio
+          size[0] / size[1].to_f
+        end
+
+        def read_fail(image_path)
+          message = "Couldn't find image for #{selector_name} at #{image_path}."
+          layout.give_up(message)
+        end
+
+        def inspect
+          str = ''
+          %w(top left width height bottom right box_width box_height
+             im_width im_height).each do |dim|
+            str << "#{dim}: #{send(dim)}; "
+          end
+          str.strip
+        end
+      end
+    end
+  end
+end

data/lib/bread/basket/poster/layout.rb

@@ -0,0 +1,108 @@
+module Bread
+  module Basket
+    module Poster
+      class Layout
+        attr_reader :metadata, :stylesheet, :css_reader, :type
+        attr_accessor :height, :width, :left, :right, :top, :bottom, :margin,
+                      :pending, :determined, :font_size, :font_family, :boxes,
+                      :image_boxes
+
+        def initialize(metadata)
+          @metadata = metadata
+          @type = determine_type
+          @stylesheet = find_stylesheet(metadata['stylesheet'])
+          @css_reader = CSSReader.new(stylesheet, self)
+          css_reader.do_your_thing!
+        end
+
+        def determine_type
+          case @metadata['layout']
+          when 'block'
+            :block
+          when 'flow'
+            :flow
+          else
+            handle_else @metadata['layout']
+            :flow
+          end
+        end
+
+        def find_stylesheet(stylesheet_name)
+          if stylesheet_name
+            path = Bread::Basket::Poster.dir_path + '/' + stylesheet_name
+            path += '.css' unless stylesheet_name.include?('.css')
+            path
+          else
+            puts 'Warning: no stylesheet given, using template instead.'
+            template
+          end
+        end
+
+        def flow?
+          type == :flow
+        end
+
+        def template
+          template = File.expand_path('./samples/block_sample.css')
+          template = File.expand_path('./samples/flow_sample.css') if flow?
+          template
+        end
+
+        def handle_else(layout)
+          if layout
+            puts "Warning: Unrecognized layout `#{layout}`, using flow instead"
+          else
+            puts 'Warning: No layout specified, defaulting to flow.'
+          end
+        end
+
+        def create_attribute(key, value)
+          new_key = key.gsub('-', '_').sub('.', '').to_sym
+          define_singleton_method(new_key) { value }
+          # This is called at end of each attribute's definition
+          try_to_resolve_pendings unless pending.nil?
+        end
+
+        def handle_defaults
+          empty_defaults
+          @font_size ||= 36
+          @font_family ||= 'Helvetica'
+          @margin ||= 36
+          # add dimensions to the determined hash for reference
+          # open to a better solution here :)
+          %w(width height left right top bottom margin font_size
+             font_family).each do |method_name|
+            determined[method_name] = eval("@#{method_name}")
+          end
+        end
+
+        def empty_defaults
+          @pending = []
+          @determined = {}
+          @boxes = []
+          @image_boxes = []
+        end
+
+        def try_to_resolve_pendings
+          pending.reverse_each do |name|
+            # very limited match on columns for now
+            match = name.match(/columns\[(\d)\]/)
+            if match
+              index = match[1].to_i
+              columns[index].try_to_resolve
+            else
+              box = send name.sub('.', '').gsub('-', '_')
+              box.try_to_resolve
+            end
+          end
+        end
+
+        def give_up(message)
+          puts '== Aborting =='
+          puts message
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/bread/basket/poster/pdf_builder.rb

@@ -0,0 +1,113 @@
+module Bread
+  module Basket
+    module Poster
+      class PDFBuilder
+        attr_reader :layout, :pdf, :text_renderer, :block_renderer, :wait_list
+
+        def initialize
+          @layout = Poster.layout
+          @wait_list = []
+          create_pdf
+          create_renderers
+        end
+
+        def create_pdf
+          page_size = [layout.width, layout.height]
+          @pdf = Prawn::Document.new(page_size: page_size, margin: 0)
+          Poster.pdf = @pdf
+        end
+
+        def create_renderers
+          @text_renderer = Redcarpet::Markdown.new(TextRenderer, TEXT_RENDERER_OPTS)
+          # @block_renderer = Redcarpet::Markdown.new(BlockRenderer)
+        end
+
+        def build
+          layout.type == :block ? build_blocks : build_flow
+        end
+
+        def build_blocks
+          # block_renderer.render layout.body
+        end
+
+        def build_flow
+          image_boxes
+          boxes_from_metadata
+          create_columns
+        end
+
+        def boxes_from_metadata
+          layout.metadata.each do |key, value|
+            next unless layout.boxes.include? '.' + key
+            box = layout.send key.gsub('-', '_')
+            box.content = value.to_s
+            try_to_build box
+            try_wait_list # rename to try wait list and rewrite a little
+          end
+        end
+
+        def try_to_build(box)
+          if box.pending.empty?
+            pdf_box = build_box(box)
+            finish_stretchy_box(box, pdf_box) if box.stretchy?
+          else
+            wait_list << box unless wait_list.include? box
+          end
+        end
+
+        def finish_stretchy_box(box, pdf_box)
+          box.height = pdf_box.height
+          box.determine_missing('bottom')
+        end
+
+        def try_wait_list
+          layout.try_to_resolve_pendings
+          wait_list.each { |box| try_to_build box }
+        end
+
+        def build_box(box)
+          opts = { width: box.width }
+          opts[:height] = box.height if box.height.is_a? Numeric
+
+          pdf.bounding_box([box.left, box.top], opts) do
+            Poster.current_styles = box.styles
+            text_renderer.render box.content
+          end
+        end
+
+        def create_columns
+          pdf.column_box(left_top, column_box_opts) do
+            Poster.current_styles = layout.column_styles
+            text_renderer.render Poster.body
+          end
+        end
+
+        def left_top
+          left_edge = layout.columns[0].left
+          top_edge = layout.columns[0].top
+          [left_edge, top_edge]
+        end
+
+        def column_box_opts
+          columns_width = pdf.bounds.width - 2 * layout.margin
+          columns_height = left_top[1] - layout.margin
+          { columns: 4, width: columns_width, height: columns_height }
+        end
+
+        def image_boxes
+          layout.image_boxes.each do |box_name|
+            image_box = layout.send box_name
+            path = image_path(image_box)
+            pdf.image path, fit: [image_box.width, image_box.height],
+                            at: [image_box.left, image_box.top]
+          end
+        end
+
+        def image_path(image_box)
+          image_src = image_box.styles['src']
+          Bread::Basket::Poster.dir_path + '/' + image_src
+        end
+      end
+    end
+  end
+end

data/lib/bread/basket/poster/poster_maker.rb

@@ -0,0 +1,55 @@
+module Bread
+  module Basket
+    module Poster
+      class PosterMaker
+        YAML_REGEX = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        ERROR_MESSAGE = <<-EOS
+
+
+        Your file must start with a YAML front matter.
+        For example:
+        ---
+        layout: flow
+        stylesheet: my_template
+        ---
+
+        EOS
+
+        attr_accessor :layout, :metadata, :body
+
+        def initialize(filename)
+          @filename = filename
+          filepath = File.expand_path(filename)
+          Poster.dir_path = File.dirname(filepath)
+          check_file
+          create_layout
+          PDFBuilder.new.build
+          render
+        end
+
+        def render
+          name = @filename.sub(/\..*/, '')
+          Poster.pdf.render_file name + '.pdf'
+        end
+
+        def check_file
+          source = File.read(@filename)
+          @matchdata = source.match(YAML_REGEX)
+          fail NoFrontMatterError, ERROR_MESSAGE unless @matchdata
+        end
+
+        def create_layout
+          @metadata = YAML.load(@matchdata[0])
+          @body = @matchdata.post_match
+          Poster.body = @body
+          @layout = Layout.new(@metadata)
+          Poster.layout = layout
+        end
+      end
+
+      # define custom error so that specs only pass if
+      # error is caused by lack of front matter
+      class NoFrontMatterError < StandardError; end
+    end
+  end
+end

data/lib/bread/basket/poster/prawn_patches/column_box.rb

@@ -0,0 +1,17 @@
+module Prawn
+  class Document
+    class ColumnBox < BoundingBox
+      # :nocov:
+      # Not testing this because I can't figure out how to do it :(
+      # so be sure to look at samples to make sure column tops are correct
+      def move_past_bottom
+        @current_column = (@current_column + 1) % @columns
+        column = ::Bread::Basket::Poster.layout.columns[@current_column]
+        @document.y = column.top
+        @document.start_new_page if @current_column == 0
+        @y = @parent.absolute_top if @reflow_margins && (@current_column == 0)
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/bread/basket/poster/text_renderer.rb

@@ -0,0 +1,89 @@
+module Bread
+  module Basket
+    module Poster
+      class TextRenderer < Redcarpet::Render::Base
+        attr_reader :pdf, :layout, :curr_styles
+
+        def preprocess(full_document)
+          @pdf = Poster.pdf
+          @layout = Poster.layout
+          @curr_styles = Poster.current_styles
+          curr_styles['font-size'] = layout.font_size unless curr_styles.key? 'font-size'
+          pdf.font_size curr_styles['font-size']
+          full_document
+        end
+
+        def alignment
+          if curr_styles['text-align']
+            curr_styles['text-align'].to_sym
+          else
+            :left
+          end
+        end
+
+        def paragraph(text)
+          pdf.text text, inline_format: true, align: alignment
+        end
+
+        def header(text, _header_level)
+          @header_maker = Poster::HeaderMaker.new(pdf, layout) unless @header_maker
+          @header_maker.create_header(text, curr_styles)
+        end
+
+        # Overloaded function for images, equations and maybe someday even code
+        def block_code(content, first_line)
+          BlockCodeHandler.new(pdf, layout, first_line, content)
+          ''
+        end
+
+        # > Quote Feature
+        # def block_quote(_quote)
+        # end
+
+        # *italic*
+        def emphasis(text)
+          "<i>#{text}</i>"
+        end
+
+        # **bold**
+        def double_emphasis(text)
+          "<b>#{text}</b>"
+        end
+
+        # _underline_
+        def underline(text)
+          "<u>#{text}</u>"
+        end
+
+        # super^script
+        def superscript(text)
+          "<sup>#{text}</sup>"
+        end
+
+        # inline `code span`
+        # def codespan(_text)
+        # end
+
+        # inline ==highlighting==
+        def highlight(text)
+          color = layout.respond_to?(:highlight) ? layout.highlight['color'] : '#f700ff'
+          color.sub!('#', '')
+          "<color rgb='#{color}'>#{text}</color>"
+        end
+
+        # first thing called on each element, it's return
+        # value gets added to the table row
+        # def table_cell(_content, _alignment)
+        # end
+
+        # called after all cells, content is their contents joined
+        # def table_row(_content)
+        # end
+
+        # called after all rows, header is header row, body is remaining rows.
+        # def table(_header, _body)
+        # end
+      end
+    end
+  end
+end