bread-basket 0.0.0 → 0.0.1

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

@@ -0,0 +1,60 @@
+module Bread
+  module Basket
+    module Poster
+      class BoxChecker
+        # Determines which dimensions were provided and if provided dimensions
+        # are sufficient to determine left, right, top, and width of box
+        # bottom and height are optional but if top is missing are required to
+        # determine location of top.
+        attr_reader :box, :dimensions
+
+        def initialize(box, dimensions)
+          @box = box
+          @dimensions = dimensions
+        end
+
+        def horizontal_dimensions
+          arr = []
+          dimensions.each_key do |key|
+            arr << key if  %w(left right width).include? key
+          end
+          warn_right if arr.length > 2
+          arr
+        end
+
+        def vertical_dimensions
+          arr = []
+          dimensions.each_key do |key|
+            arr << key if  %w(top bottom height).include? key
+          end
+          warn_bottom if arr.length > 2
+          arr
+        end
+
+        def horizontal_ok?
+          horiz = %w(left right width) - horizontal_dimensions
+          horiz.length < 2
+        end
+
+        def vertical_ok?
+          bottom_and_height = %w(bottom height).all? { |s| dimensions.key? s }
+          dimensions.key?('top') || bottom_and_height
+        end
+
+        def box_ok?
+          horizontal_ok? && vertical_ok?
+        end
+
+        def warn_right
+          puts "Warning: For selector #{box.selector_name}, left, width AND right were " \
+                'provided. Right will be ignored.'
+        end
+
+        def warn_bottom
+          puts "Warning: For selector #{box.selector_name}, top, height AND bottom were " \
+                'provided. Bottom will be ignored.'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Bread
+  module Basket
+    module Poster
+      class Columns
+        # Columns are a special type of bounding box in prawn so they get their
+        # own class here to handle their dimensions.
+        attr_reader :specs, :count, :layout, :tops, :width, :lefts, :boxes, :spacing
+
+        def initialize(specs, layout)
+          @specs = specs
+          @layout = layout
+          check_specs
+          @count = specs['count'].to_i
+          @spacing = specs['font-size'] || layout.font_size
+          init_tops
+          init_widths
+          init_lefts
+          create_boxes
+        end
+
+        def init_tops
+          if specs['top'].is_a? Array
+            @tops = tops_from_arr
+          else
+            @tops = Array.new(count, specs['top'])
+          end
+        end
+
+        def tops_from_arr
+          case specs['top'].length
+          when (count / 2.0).ceil
+            symmetric_tops!
+          when count
+            specs['top']
+          else
+            message = 'Columns top specification has wrong length'
+            layout.give_up(message)
+          end
+        end
+
+        def symmetric_tops!
+          arr = specs['top'].clone
+          specs['top'].pop if count.odd?
+          specs['top'].reverse!
+          arr + specs['top']
+        end
+
+        def init_widths
+          col_spacing = spacing * (count - 1) # from Prawn
+          @width = (columns_width - col_spacing) / count.to_f
+        end
+
+        def columns_width
+          total_margin_space = 2 * layout.margin
+          layout.width - total_margin_space
+        end
+
+        def init_lefts
+          column_width = width + spacing # again from Prawn
+          @lefts = count.times.inject([layout.margin]) do |a|
+            a << a[-1] + column_width
+          end
+          @lefts.pop
+        end
+
+        def create_boxes
+          @boxes = []
+          count.times do |index|
+            box = Box.new "columns[#{index}]",
+                          layout,
+                          'top' => tops[index],
+                          'left' => lefts[index],
+                          'width' => width,
+                          'bottom' => layout.margin
+            @boxes << box
+          end
+        end
+
+        def check_specs
+          message = '.columns selector must include top and count to be valid'
+          layout.give_up(message) unless top_and_count?
+        end
+
+        def top_and_count?
+          %w(top count).all? { |attr| specs.key? attr }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Bread
+  module Basket
+    module Poster
+      class CSSReader
+        # The CSSReader reads in the css and then creates:
+        #  - layout
+        #  - columns (if flow)
+        #  - boxes (Box or ImageBox)
+        # and then attaches #-styles to the layout help
+        include CssParser
+        include UnitsHelper
+        attr_reader :parser, :layout
+
+        COLUMNS_FAIL = 'To use a flow layout your stylesheet must include ' \
+                       '.columns selector.'
+        LAYOUT_FAIL = 'Your stylesheet must include the .layout selector.'
+
+        def initialize(stylesheet_path, layout)
+          @layout = layout
+          @parser = CssParser::Parser.new
+          @parser.load_file!(stylesheet_path)
+        end
+
+        def do_your_thing!
+          init_layout
+          create_columns if layout.flow?
+          create_bounding_boxes
+          create_styles
+        end
+
+        def init_layout
+          layout_rules = parser.find_by_selector '.layout'
+          layout.give_up LAYOUT_FAIL if layout_rules.empty?
+          specs = rules_to_specs(layout_rules[0])
+          create_layout_attributes(specs)
+          layout.handle_defaults
+        end
+
+        def create_layout_attributes(specs)
+          attributes_from_specs(specs)
+          finish_layout_box
+        end
+
+        def attributes_from_specs(specs)
+          layout.width = specs.delete 'width'
+          layout.height = specs.delete 'height'
+          layout.margin = specs.delete 'margin'
+          specs.each do |k, v|
+            layout.create_attribute(k, v)
+          end
+        end
+
+        def finish_layout_box
+          layout.left = 0
+          layout.right = layout.width
+          layout.bottom = 0
+          layout.top = layout.height
+        end
+
+        def create_columns
+          columns = parser.find_by_selector '.columns'
+          layout.give_up COLUMNS_FAIL if columns.empty?
+          specs = rules_to_specs(columns[0])
+          columns = Columns.new specs, layout
+          layout.create_attribute('columns', columns.boxes)
+          layout.create_attribute('column_styles', specs)
+        end
+
+        def create_bounding_boxes
+          parser.each_selector do |selector, declarations|
+            next if skip_selector? selector
+            method_name = to_method_name selector
+            specs = rules_to_specs declarations
+            box = create_box selector, layout, specs
+            layout.create_attribute(method_name, box)
+          end
+        end
+
+        def skip_selector?(selector)
+          old_selector = %w(.layout .columns).include? selector
+          hash_selector = selector =~ HASH_SELECTOR_REGEX
+          old_selector || hash_selector
+        end
+
+        def create_box(selector, layout, specs)
+          if specs.key?('src')
+            ImageBox.new selector, layout, specs
+          else
+            Box.new selector, layout, specs
+          end
+        end
+
+        def create_styles
+          parser.each_selector do |selector, declarations|
+            next unless selector =~ HASH_SELECTOR_REGEX
+            method_name = to_method_name selector
+            specs = rules_to_specs declarations
+            layout.create_attribute(method_name, specs)
+          end
+        end
+
+        def rules_to_specs(css_rules)
+          # rule => "top: title.bottom, authors.bottom"
+          # spec => { top: ['title.bottom', 'authors.bottom'] }
+          rules_arr = css_rules.split(';')
+          hash = {}
+
+          rules_arr.each { |rule| rule_to_hash(rule, hash) }
+
+          hash.each_with_object({}) do |(k, v), h|
+            arr = v.map { |value| convert_units(value) }
+            h[k] = arr.length == 1 ? arr[0] : arr
+          end
+        end
+
+        def rule_to_hash(rule, hash)
+          rule_arr = rule.split(':')
+          key = rule_arr[0].strip
+          value_arr = rule_arr[1].strip.split(',')
+          value_arr.map!(&:strip)
+          hash[key] = value_arr
+        end
+
+        def to_method_name(hash_selector)
+          hash_selector.sub('#', '').sub('.', '').gsub('-', '_')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+module Bread
+  module Basket
+    module Poster
+      class DimensionsHelper
+        # Dimensions Helper checks the dimensions and determines how to handle
+        # them (pending vs numeric)
+        include UnitsHelper
+        attr_reader :box, :layout, :dimensions, :checker
+
+        def initialize(box, layout, dimensions)
+          @layout = layout
+          @box = box
+          @dimensions = dimensions
+          @checker = BoxChecker.new box, dimensions
+          fail_dimensions unless checker.box_ok?
+          determine_dimensions
+          box.try_to_resolve
+          frame_box
+        end
+
+        def fail_dimensions
+          message = "For the selector #{box.selector_name}, you failed to " \
+          'provide enough dimensions to draw a box. You need two of these three: ' \
+          'left, right, width; and either `top` or `bottom and height`. Instead you ' \
+          "provided #{dimensions}."
+          layout.give_up message
+        end
+
+        def determine_dimensions
+          dimensions.each do |key, value|
+            next unless DIMENSIONS.include? key
+            case value
+            when String
+              create_pending_dimension key, value
+            when Numeric
+              add_numeric_dimension key, value
+            end
+          end
+        end
+
+        def add_numeric_dimension(dimension_name, value)
+          box.instance_variable_set "@#{dimension_name}", value
+          box.add_to_determined(dimension_name, value)
+        end
+
+        def create_pending_dimension(dimension_name, command_string)
+          box.pending << dimension_name
+          commands = command_array command_string
+          pending = create_pending_hash commands
+          return_hash = { pending: pending, command: commands }
+          box.instance_variable_set "@#{dimension_name}", return_hash
+        end
+
+        def command_array(command_string)
+          commands = command_string.split(' ')
+          commands.map { |command| convert_command(command) }
+        end
+
+        def convert_command(command)
+          case command
+          when '*', '+', '-', '/'
+            command.to_sym
+          when layout.css_reader.class::NUMERIC_REGEX
+            Float command
+          else
+            command.gsub('-', '_')
+          end
+        end
+
+        def create_pending_hash(command_array)
+          h = {}
+          command_array.each_with_index do |command, index|
+            if (command.is_a? String) && (command != '(') && (command != ')')
+              h[command] = index
+            end
+          end
+          h
+        end
+
+        def frame_box
+          # from two of left, right, width, determine other dimension
+          # bottom, height are optional unless top is missing
+          left_right_width
+          top_bottom_height
+        end
+
+        def left_right_width
+          given = checker.horizontal_dimensions
+          difference = %w(left right width) - given
+          missing = difference.empty? ? 'right' : difference[0]
+          missing_dimension given, missing
+        end
+
+        def top_bottom_height
+          given = checker.vertical_dimensions
+          difference = %w(top bottom height) - given
+          case difference.length
+          when 0
+            missing_dimension given, 'bottom'
+          when 1
+            missing_dimension given, difference[0]
+          when 2
+            make_stretchy
+          end
+        end
+
+        def missing_dimension(given, missing)
+          if given.any? { |dim| box.pending.include? dim }
+            box.unfinished << missing
+          else
+            box.determine_missing missing
+          end
+        end
+
+        def make_stretchy
+          box.add_to_determined 'bottom', :stretchy
+          box.add_to_determined 'height', :stretchy
+          box.stretchy = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Bread
+  module Basket
+    module Poster
+      class HeaderCallback
+        def initialize(document, options)
+          @color = options['background-color']
+          @document = document
+          @radius = options['radius']
+          @height = options['height']
+          @width = options['width']
+        end
+
+        def render_behind(fragment)
+          original_color = @document.fill_color
+          vert_dist = (@height - fragment.height) / 2
+
+          # TODO: If you want to get real picky, the vertical centering should
+          # be aware of whether the text has ascenders or descenders, there's
+          # a prawn method for calculating that sort of thing precisely.
+          left_top = [@document.bounds.left, fragment.top + vert_dist]
+
+          @document.fill_color = @color.sub('#', '')
+          @document.fill_rounded_rectangle(left_top, @width, @height, @radius)
+          @document.fill_color = original_color
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Bread
+  module Basket
+    module Poster
+      class HeaderMaker
+        attr_reader :pdf, :layout, :styles
+
+        HEADER_DEFAULTS =
+        { 'font-size' => 36,
+          'color' => '000000',
+          'margin-top' => 0,
+          'margin-bottom' => 0,
+          'radius' => 0,
+          'background-color' => 'ffffff',
+          'font-family' => 'Helvetica'
+        }
+
+        def initialize(pdf, layout)
+          @pdf = pdf
+          @layout = layout
+        end
+
+        def create_header(text, styles)
+          @text = text
+          @styles = init_styles(styles)
+          @header_callback = Poster::HeaderCallback.new(pdf, @styles)
+
+          pdf.move_down top_margin
+          pdf.formatted_text_box text_box_arr, text_box_opts
+          pdf.move_down bottom_margin
+
+          text # don't return a Numeric, Redcarpet hates that!
+        end
+
+        def init_styles(styles)
+          styles = HEADER_DEFAULTS.merge layout_styles
+          styles['width'] = layout.columns[0].width unless styles.key? 'width'
+          styles['height'] = styles['font-size'] * 2 unless styles.key? 'height'
+          styles
+        end
+
+        def layout_styles
+          if layout.respond_to? :header
+            layout.header
+          else
+            {}
+          end
+        end
+
+        def text_box_arr
+          [{ text: @text,
+             callback: @header_callback,
+             color: styles['color'].sub('#', ''),
+             font:  styles['font-family'],
+             size: styles['font-size']
+            }]
+        end
+
+        def text_box_opts
+          { at: [pdf.bounds.left, pdf.cursor],
+            width: layout.columns[0].width,
+            align: :center }
+        end
+
+        def top_margin
+          styles['margin-top'] + (styles['height'] - styles['font-size']) / 2
+        end
+
+        def bottom_margin
+          styles['margin-bottom'] + styles['height']
+        end
+      end
+    end
+  end
+end