squib 0.15.3 → 0.17.0

data/lib/squib/graphics/save_images.rb

@@ -1,22 +1,24 @@
+require_relative 'cairo_context_wrapper'
+
 module Squib
   class Card
 
     # :nodoc:
     # @api private
-    def save_png(batch)
-      surface = if preprocess_save?(batch)
+    def save_png(batch, shadow)
+      surface = if preprocess_save?(batch, shadow)
                   w, h = compute_dimensions(batch.rotate, batch.trim)
-                  preprocessed_save(w, h, batch)
+                  preprocessed_save(w, h, batch, shadow)
                 else
                   @cairo_surface
                 end
-      write_png(surface, index, batch.dir, batch.prefix, batch.count_format)
+      write_png(surface, index, batch)
     end
 
     # :nodoc:
     # @api private
-    def preprocess_save?(batch)
-      batch.rotate != false || batch.trim > 0
+    def preprocess_save?(batch, shadow)
+      batch.rotate != false || batch.trim > 0 || !(shadow.shadow_radius.nil?)
     end
 
     def compute_dimensions(rotate, trim)
@@ -27,25 +29,62 @@ module Squib
       end
     end
 
-    def preprocessed_save(width, height, batch)
-      new_cc = Cairo::Context.new(Cairo::ImageSurface.new(width, height))
+    def preprocessed_save(w, h, batch, shadow)
+      new_cc = Cairo::Context.new(Cairo::ImageSurface.new(w, h))
       trim_radius = batch.trim_radius
       if batch.rotate != false
-        new_cc.translate(width * 0.5, height * 0.5)
-        new_cc.rotate(batch.angle)
-        new_cc.translate(height * -0.5, width * -0.5)
-        new_cc.rounded_rectangle(0, 0, height, width, trim_radius, trim_radius)
+        new_cc.translate w * 0.5, h * 0.5
+        new_cc.rotate batch.angle
+        new_cc.translate h * -0.5, w * -0.5
+        new_cc.rounded_rectangle(0, 0, h, w, trim_radius, trim_radius)
       else
-        new_cc.rounded_rectangle(0, 0, width, height, trim_radius, trim_radius)
+        new_cc.rounded_rectangle(0, 0, w, h, trim_radius, trim_radius)
       end
       new_cc.clip
       new_cc.set_source(@cairo_surface, -batch.trim, -batch.trim)
       new_cc.paint
+      new_cc.reset_clip
+      new_cc = drop_shadow(new_cc, shadow, batch) unless shadow.shadow_radius.nil?
       return new_cc.target
     end
 
-    def write_png(surface, i, dir, prefix, count_format)
-      surface.write_to_png("#{dir}/#{prefix}#{count_format % i}.png")
+    # pseudo-blur behave weirdly with a radius of 0 - wrapping
+    def blur(cc, r, &block)
+      if r == 0
+        yield(block)
+      else
+        cc.pseudo_blur(r, &block)
+      end
+    end
+
+    def drop_shadow(cc, s, batch)
+      off_x = s.shadow_offset_x
+      off_y = s.shadow_offset_y
+      s_trim = s.shadow_trim
+      s_rad = s.shadow_radius
+      new_w = cc.target.width  + off_x + 3 * s_rad - (2 * s_trim)
+      new_h = cc.target.height + off_y + 3 * s_rad - (2 * s_trim)
+      new_cc = Squib::Graphics::CairoContextWrapper.new(
+        Cairo::Context.new(Cairo::ImageSurface.new(new_w, new_h)))
+      blur(new_cc, s_rad) do
+        # fill in with shadow color
+        new_cc.set_source_squibcolor s.shadow_color
+        new_cc.rectangle 0, 0, new_cc.target.width, new_cc.target.height
+        new_cc.fill
+        # then, paint but blend with :dest_in to get a shadow-shaped drawing
+        new_cc.set_source cc.target, s_rad + off_x, s_rad + off_y
+        new_cc.operator = :dest_in # see https://www.cairographics.org/operators/
+        new_cc.paint
+      end
+      new_cc.set_source cc.target, s_rad, s_rad
+      new_cc.operator = :over
+      new_cc.paint
+      return new_cc
+    end
+
+    def write_png(surface, i, b)
+      filename = "#{b.dir}/#{b.prefix}#{b.count_format % i}#{b.suffix}.png"
+      surface.write_to_png filename
     end
 
   end

data/lib/squib/graphics/save_sprue.rb

@@ -5,7 +5,7 @@ module Squib
       def initialize(deck, tmpl, sheet_args)
         @deck = deck
         @tmpl = tmpl
-        @page_number = 1
+        @page_number = 0
         @sheet_args = sheet_args # might be Args::Sheet or Args::SaveBatch
         @overlay_lines = @tmpl.crop_lines.select do |line|
           line['overlay_on_cards']
@@ -39,7 +39,7 @@ module Squib
           end
 
           draw_overlay_above_cards cc
-          cc.target.finish
+          draw_final_page cc # See bug #320
         end
       end
 
@@ -190,6 +190,11 @@ module Squib
         cc
       end
 
+      def draw_final_page(cc)
+        # PDF doesn't need to create a last page. See bug #320
+        cc.target.finish
+      end 
+
       def full_filename
         @sheet_args.full_filename
       end
@@ -211,6 +216,13 @@ module Squib
         cc
       end
 
+      # The last page always gets written out for PNGs because they are separate
+      # files and don't get "flushed" automatically. See bug #320.
+      def draw_final_page(cc)
+        draw_page cc
+        cc.target.finish
+      end
+
       def full_filename
         @sheet_args.full_filename @page_number
       end

data/lib/squib/graphics/text.rb

@@ -76,7 +76,7 @@ module Squib
 
     # # :nodoc:
     # # @api private
-    def embed_images!(embed, str, layout, valign)
+    def embed_images!(embed, str, layout, valign, scale)
       return [] unless embed.rules.any?
       layout.markup = str
       clean_str     = layout.text
@@ -84,7 +84,7 @@ module Squib
       EmbeddingUtils.indices(clean_str, embed.rules.keys).each do |key, ranges|
         rule = embed.rules[key]
         ranges.each do |range|
-          carve = Pango::Rectangle.new(0, 0, compute_carve(rule, range), 0)
+          carve = Pango::Rectangle.new(0, 0, compute_carve(rule, range) * scale, 0)
           att = Pango::AttrShape.new(carve, carve, rule)
           att.start_index = range.first
           att.end_index = range.last
@@ -100,7 +100,7 @@ module Squib
           y = Pango.pixels(layout.index_to_pos(att.start_index).y) +
                 rule[:adjust].dy[@index] +
                 compute_valign(layout, valign, rule[:box].height[@index])
-          rule[:draw].call(self, x, y)
+          rule[:draw].call(self, x, y, scale)
           cxt.reset_clip
           [cxt, att, do_path]
         end
@@ -121,19 +121,46 @@ module Squib
        end
     end
 
-    # :nodoc:
     # @api private
     def text(embed, para, box, trans, draw, dpi)
+        font_desc = Pango::FontDescription.new(para.font)
+        font_desc.size = para.font_size * Pango::SCALE if para.font_size.is_a? Numeric
+        orig_font_size = font_desc.size
+        
+        # If text autoscaling is enabled, find the largest text size (smaller or equal to the set text size) that fits
+        if para.ellipsize == :autoscale
+            para.ellipsize = Pango::EllipsizeMode::END
+            sizes = sizes = (1 .. font_desc.size).to_a.reverse
+            
+            # Dummy render to an area outside the card with decreasing font sizes until text no longer ellipsizes
+            max_fitting_size = sizes.bsearch{ |sz|
+                font_desc.size = sz
+                extents = render_text(embed, para, box, trans, draw, dpi, font_desc, orig_font_size, true)
+                !extents[:ellipsized]
+            }
+            
+            if max_fitting_size.nil?
+                max_fitting_size = sizes.last
+                Squib.logger.warn{"Could not autosize for Card \##{@index} as minimum specified size #{max_fitting_size} still ellipsizes."}
+            end
+            font_desc.size = max_fitting_size
+        end
+
+        render_text(embed, para, box, trans, draw, dpi, font_desc, orig_font_size, false)
+    end
+
+    # :nodoc:
+    # @api private
+    def render_text(embed, para, box, trans, draw, dpi, font_desc, orig_font_size, dummy_draw)
       Squib.logger.debug {"Rendering text with: \n#{para} \nat:\n #{box} \ndraw:\n #{draw} \ntransform: #{trans}"}
       extents = nil
       use_cairo do |cc|
         cc.set_source_squibcolor(draw.color)
         cc.translate(box.x, box.y)
+        cc.translate(-10000, -10000) if dummy_draw
         cc.rotate(trans.angle)
         cc.move_to(0, 0)
 
-        font_desc      = Pango::FontDescription.new(para.font)
-        font_desc.size = para.font_size * Pango::SCALE unless para.font_size.nil?
         layout         = cc.create_pango_layout
         layout.font_description = font_desc
         layout.text = para.str.to_s
@@ -152,7 +179,7 @@ module Squib
         layout.justify = para.justify unless para.justify.nil?
         layout.spacing = para.spacing unless para.spacing.nil?
 
-        embed_images!(embed, para.str, layout, para.valign)
+        embed_images!(embed, para.str, layout, para.valign, font_desc.size / orig_font_size.to_f)
 
         vertical_start = compute_valign(layout, para.valign, 0)
         cc.move_to(0, vertical_start)
@@ -164,8 +191,9 @@ module Squib
         stroke_outline!(cc, layout, draw) if draw.stroke_strategy == :fill_first
         draw_text_hint(cc, box.x, box.y, layout, para.hint)
         extents = { width: layout.extents[1].width / Pango::SCALE,
-                    height: layout.extents[1].height / Pango::SCALE }
-        warn_if_ellipsized layout
+                    height: layout.extents[1].height / Pango::SCALE,
+                    ellipsized: layout.ellipsized?}
+        warn_if_ellipsized layout unless dummy_draw
       end
       return extents
     end

data/lib/squib/import/csv_importer.rb

@@ -0,0 +1,45 @@
+require 'csv'
+require_relative 'quantity_exploder'
+
+module Squib::Import
+  class CsvImporter
+    include Squib::Import::QuantityExploder
+    def import_to_dataframe(import, csv_opts, &block)
+      data = import.data.nil? ? File.read(import.file) : import.data
+      table = CSV.parse(data, **csv_opts.to_hash)
+      check_duplicate_csv_headers(table)
+      hash = Squib::DataFrame.new
+      table.headers.each do |header|
+        new_header = header.to_s
+        new_header = new_header.strip if import.strip?
+        hash[new_header] ||= table[header]
+      end
+      if import.strip?
+        new_hash = Squib::DataFrame.new
+        hash.each do |header, col|
+          new_hash[header] = col.map do |str|
+            str = str.strip if str.respond_to?(:strip)
+            str
+          end
+        end
+        hash = new_hash
+      end
+      unless block.nil?
+        hash.each do |header, col|
+          col.map! do |val|
+            yield(header, val)
+          end
+        end
+      end
+      return explode_quantities(hash, import.explode)
+    end
+
+    def check_duplicate_csv_headers(table)
+      if table.headers.size != table.headers.uniq.size
+        dups = table.headers.select{|e| table.headers.count(e) > 1 }
+        Squib.logger.warn "CSV duplicated the following column keys: #{dups.join(',')}"
+      end
+    end
+  end
+end
+

data/lib/squib/import/quantity_exploder.rb

@@ -0,0 +1,18 @@
+module Squib
+  module Import
+    module QuantityExploder
+      def explode_quantities(data, qty)
+        return data unless data.col? qty.to_s.strip
+        qtys = data[qty]
+        new_data = Squib::DataFrame.new
+        data.each do |col, arr|
+          new_data[col] = []
+          qtys.each_with_index do |qty, index|
+            qty.to_i.times { new_data[col] << arr[index] }
+          end
+        end
+        return new_data
+      end
+    end
+  end
+end

data/lib/squib/import/xlsx_importer.rb

@@ -0,0 +1,28 @@
+require 'roo'
+require_relative 'quantity_exploder'
+
+module Squib::Import
+  class XlsxImporter
+    include Squib::Import::QuantityExploder
+    def import_to_dataframe(import, &block)
+      s = Roo::Excelx.new(import.file)
+      s.default_sheet = s.sheets[import.sheet]
+      data = Squib::DataFrame.new
+      s.first_column.upto(s.last_column) do |col|
+        header = s.cell(s.first_row, col).to_s
+        header.strip! if import.strip?
+        data[header] = []
+        (s.first_row + 1).upto(s.last_row) do |row|
+          cell = s.cell(row, col)
+          # Roo hack for avoiding unnecessary .0's on whole integers (https://github.com/roo-rb/roo/issues/139)
+          cell = s.excelx_value(row, col) if s.excelx_type(row, col) == [:numeric_or_formula, 'General']
+          cell.strip! if cell.respond_to?(:strip) && import.strip?
+          cell = block.yield(header, cell) unless block.nil?
+          data[header] << cell
+        end# row
+      end# col
+      explode_quantities(data, import.explode)
+    end
+  end
+end
+

data/lib/squib/import/yaml_importer.rb

@@ -0,0 +1,30 @@
+require 'yaml'
+require_relative 'data_frame'
+require_relative 'quantity_exploder'
+
+module Squib::Import
+  class YamlImporter
+    include Squib::Import::QuantityExploder
+    def import_to_dataframe(import, &block)
+      data = import.data.nil? ? File.read(import.file) : import.data
+      yml = YAML.load(data)
+      data = Squib::DataFrame.new
+      # Get a universal list of keys to ensure everything is covered.
+      keys = yml.map { |c| c.keys}.flatten.uniq
+      keys.each { |k| data[k] = [] } #init arrays
+      yml.each do |card|
+      # nil value if key isn't set.
+      keys.each { |k| data[k] << card[k] }
+      end
+      unless block.nil?
+        data.each do |header, col|
+          col.map! do |val|
+          block.yield(header, val)
+          end
+        end
+      end
+      explode_quantities(data, import.explode)
+    end
+  end
+end
+

data/lib/squib/layout_parser.rb

@@ -1,12 +1,15 @@
 require 'yaml'
+require_relative 'args/xywh_shorthands'
 
 module Squib
   # Internal class for handling layouts
   # @api private
   class LayoutParser
+    include Args::XYWHShorthands
 
-    def initialize(dpi = 300)
+    def initialize(dpi = 300, cell_px = 37.5)
       @dpi = dpi
+      @cell_px = cell_px
     end
 
     # Load the layout file(s), if exists
@@ -67,6 +70,9 @@ module Squib
     end
 
     def handle_relative_operators(parent_val, child_val)
+      if uses_operator?(child_val) && !has_digits?(parent_val) && !has_digits?(child_val)
+        raise "Layout parse error: can't combine #{parent_val} and #{child_val}"
+      end
       if child_val.to_s.strip.start_with?('+=')
         add_parent_child(parent_val, child_val)
       elsif child_val.to_s.strip.start_with?('-=')
@@ -81,29 +87,40 @@ module Squib
     end
 
     def add_parent_child(parent, child)
-      parent_pixels = Args::UnitConversion.parse(parent, @dpi).to_f
-      child_pixels = Args::UnitConversion.parse(child.sub('+=', ''), @dpi).to_f
+      parent_pixels = Args::UnitConversion.parse(parent, @dpi, @cell_px).to_f
+      child_pixels = Args::UnitConversion.parse(child.sub('+=', ''), @dpi, @cell_px).to_f
       parent_pixels + child_pixels
     end
 
     def sub_parent_child(parent, child)
-      parent_pixels = Args::UnitConversion.parse(parent, @dpi).to_f
-      child_pixels = Args::UnitConversion.parse(child.sub('-=', ''), @dpi).to_f
+      parent_pixels = Args::UnitConversion.parse(parent, @dpi, @cell_px).to_f
+      child_pixels = Args::UnitConversion.parse(child.sub('-=', ''), @dpi, @cell_px).to_f
       parent_pixels - child_pixels
     end
 
     def mul_parent_child(parent, child)
-      parent_pixels = Args::UnitConversion.parse(parent, @dpi).to_f
+      parent_pixels = Args::UnitConversion.parse(parent, @dpi, @cell_px).to_f
       child_float = child.sub('*=', '').to_f
       parent_pixels * child_float
     end
 
     def div_parent_child(parent, child)
-      parent_pixels = Args::UnitConversion.parse(parent, @dpi).to_f
+      parent_pixels = Args::UnitConversion.parse(parent, @dpi, @cell_px).to_f
       child_float = child.sub('/=', '').to_f
       parent_pixels / child_float
     end
 
+    # For relative operators, it's difficult for us to handle
+    # some of the shorthands - so let's just freak out if you're trying to use
+    # relative operators with words, e.g. "middle += 0.5in"
+    def has_digits?(arg)
+      /.*\d.*/ === arg.to_s
+    end
+
+    def uses_operator?(arg)
+      /^[+=|\-=|\/=|*=].*/ === arg.to_s
+    end
+
     # Does this layout entry have an extends field?
     # i.e. is it a base-case or will it need recursion?
     # :nodoc:

data/lib/squib/sprues/crop_line.rb

@@ -3,21 +3,21 @@ module Squib
     class CropLine
       attr_reader :x1, :y1, :x2, :y2
 
-      def initialize(type, position, sheet_width, sheet_height, dpi)
+      def initialize(type, position, sheet_width, sheet_height, dpi, cell_px)
         method = "parse_#{type}"
-        send method, position, sheet_width, sheet_height, dpi
+        send method, position, sheet_width, sheet_height, dpi, cell_px
       end
 
-      def parse_horizontal(position, sheet_width, _, dpi)
-        position = Args::UnitConversion.parse(position, dpi)
+      def parse_horizontal(position, sheet_width, _, dpi, cell_px)
+        position = Args::UnitConversion.parse(position, dpi, cell_px)
         @x1 = 0
         @y1 = position
         @x2 = sheet_width
         @y2 = position
       end
 
-      def parse_vertical(position, _, sheet_height, dpi)
-        position = Args::UnitConversion.parse(position, dpi)
+      def parse_vertical(position, _, sheet_height, dpi, cell_px)
+        position = Args::UnitConversion.parse(position, dpi, cell_px)
         @x1 = position
         @y1 = 0
         @x2 = position